> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ Mutable Member Variable The `mutable` specifier in C++ dictates that a class data member is never `const`, permitting its modification even when the instantiated object is declared as `const` or when accessed from within a `const`-qualified member function. Since C++11, `mutable` is also applied to lambda expressions to remove the implicit `const` qualification from the generated closure object's `operator()`. It effectively exempts specific variables from the compiler's bitwise constness enforcement, enabling logical constness without invoking Undefined Behavior. ## Syntax The `mutable` keyword precedes the data type in a member variable declaration, or follows the parameter list in a lambda expression: ```cpp theme={"dark"} // Class member syntax class ClassName { private: mutable DataType variableName; }; // Lambda expression syntax auto lambdaName = [capture]() mutable { // ... }; ``` ## Technical Mechanics ### Class Data Members When a member function is qualified with `const`, the implicit `this` pointer passed to the function changes its type from `ClassName*` to `const ClassName*`. Consequently, all non-static data members accessed through `this` are treated as `const` within the scope of that function. Applying the `mutable` specifier does not "strip" or cast away constness (which would imply `const_cast` behavior). Instead, it instructs the compiler that the specific member is *never* `const`. This makes modifications perfectly well-defined, even if the containing object is strictly `const`. ```cpp theme={"dark"} class StateMachine { private: int standardState; mutable int bypassState; public: StateMachine() : standardState(0), bypassState(0) {} // const-qualified member function void evaluate() const { // standardState = 1; // Error: assignment of member in read-only object bypassState = 1; // Success: mutable member is never const } }; int main() { const StateMachine machine; machine.evaluate(); return 0; } ``` ### Lambda Expressions When a lambda captures variables by value, the compiler generates an anonymous closure class where those captures are stored as data members. By default, the generated `operator()` for this closure class is `const`-qualified, preventing the modification of captured values. Appending `mutable` to the lambda signature removes the `const` qualification from `operator()`, allowing the internal state of the closure object to be modified. ```cpp theme={"dark"} int counter = 0; // 'counter' is captured by value auto increment = [counter]() mutable { counter++; // Success: operator() is not const, captured value can be modified return counter; }; ``` ## Logical Constness and Thread Safety In C++11 and later, the `const` qualifier establishes a strict contract for thread-safe read access. Concurrent invocations of `const` member functions on the same object are expected to be free of data races. Because `mutable` permits state mutation within a `const` context, it inherently violates this thread-safety contract unless explicitly synchronized. Modifying a `mutable` variable in a `const` method introduces potential data races in multithreaded environments. To safely maintain logical constness, `mutable` variables must be paired with synchronization primitives. In scenarios requiring lazy initialization, the internal state must be updated during a read operation. Both the synchronization primitive and the data being initialized must be marked `mutable` to allow modification within the `const` accessor. ```cpp theme={"dark"} #include class ThreadSafeCache { private: mutable std::mutex cacheMutex; mutable int cachedValue; mutable bool isCached; public: ThreadSafeCache() : cachedValue(0), isCached(false) {} int getValue() const { std::lock_guard lock(cacheMutex); // Mutating a mutable mutex if (!isCached) { // Mutating mutable data members inside a const function cachedValue = 42; isCached = true; } return cachedValue; } }; ``` ## Language Constraints The C++ standard imposes strict limitations on where and how `mutable` can be applied: 1. **Permitted Contexts:** `mutable` can only be applied to non-static class data members and lambda expressions. It cannot be applied to standalone local variables, global variables, or function parameters. 2. **Mutually Exclusive with `static`:** A member cannot be both `static` and `mutable`. Static members are bound to the class rather than a specific object instance, rendering object-level constness irrelevant. ```cpp theme={"dark"} ``` static mutable int value; // Compiler Error ```` 3. **Mutually Exclusive with `const`:** A member cannot be declared as both `const` and `mutable`. ```cpp mutable const int value; // Compiler Error ```` 4. **No Reference Types:** The `mutable` specifier cannot be applied to reference members. References inherently cannot be reseated after initialization, and their constness rules apply to the referenced object, not the reference itself. ```cpp theme={"dark"} ``` mutable int& value; // Compiler Error ```

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More

```