Пятнадцать байтов на стек от конца

Notes

• Constness in C++: In Rust, Cell<T> shines because it subverts the immutability of shared references. In C++, if you make a Cell const, set and replace won’t work without some trickery. Rust’s Cell uses its internal implementation to allow mutation through a shared reference, but in C++, const objects are immutable unless you use mutable or const_cast. By making the value member mutable, we allow the Cell to modify its contents even when the Cell object itself is const, mimicking how Rust permits mutation through a shared reference.
• Using mutable here lets Cell behave more like Rust’s version, where the container’s constness doesn’t prevent internal mutation. This is closer to “interior mutability,” but it’s a bit of a cheat in C++ - use it carefully, as it might surprise other developers expecting const to mean full immutability.
• Move-Only Types: Rust’s Cell<T> works with any T, even non-copyable types, since get requires Copy but set and replace don’t. In C++, if T is move-only (e.g., std::unique_ptr), get() as written above won’t compile. You could add a std::enable_if to disable get() for non-copyable types or provide a separate get_ref() method returning const T&.

Example usage

int main() {
    // Non-const Cell
    Cell<int> cell(42);
    std::cout << "Initial value: " << cell.get() << "\n"; // Prints 42

    cell.set(100);
    std::cout << "After set: " << cell.get() << "\n";    // Prints 100

    int old = cell.replace(200);
    std::cout << "Old value: " << old << "\n";           // Prints 100
    std::cout << "New value: " << cell.get() << "\n";    // Prints 200

    // Const Cell
    const Cell<int> const_cell(300);
    std::cout << "Const cell initial value: " << const_cell.get() << "\n"; // Prints 300

    const_cell.set(400); // Works despite constness!
    std::cout << "Const cell after set: " << const_cell.get() << "\n";     // Prints 400

    int old_const = const_cell.replace(500);
    std::cout << "Const cell old value: " << old_const << "\n";           // Prints 400
    std::cout << "Const cell new value: " << const_cell.get() << "\n";    // Prints 500

    return 0;
}

Initial value: 42
After set: 100
Old value: 100
New value: 200
Const cell initial value: 300
Const cell after set: 400
Const cell old value: 400
Const cell new value: 500

Why This Works

• The mutable keyword tells C++ that value can be modified even in a const context. This is the key to achieving “interior mutability” in C++, akin to how Rust’s Cell<T> bypasses reference immutability.
• std::move is still used for efficiency, ensuring we don’t unnecessarily copy objects when setting or replacing values.
• Like Rust’s Cell<T>, this isn’t thread-safe—use it in single-threaded scenarios or add synchronization if needed.