C++ Mutable Lambda

​

Syntax

[capture_list](parameters) mutable -> return_type {
    // body
};

int x = 0;
auto valid_cpp23 = [x] mutable { x++; };   // Valid in C++23; Syntax Error in C++11 through C++20
auto valid_all   = [x]() mutable { x++; }; // Valid in all standard versions

​

Under the Hood: The Closure Object

​

Default Lambda (Non-Mutable)

int x = 10;
auto standard_lambda = [x]() { 
    // x++; // ERROR: assignment of read-only variable 'x'
};

class __Lambda_Default {
    int x; // Captured by value
public:
    __Lambda_Default(int _x) : x(_x) {}
    
    // operator() is implicitly const
    void operator()() const { 
        // x++; // Fails because 'this' is const
    }
};

​

Mutable Lambda

int x = 10;
auto mutable_lambda = [x]() mutable { 
    x++; 
};

class __Lambda_Mutable {
    int x; // Captured by value
public:
    __Lambda_Mutable(int _x) : x(_x) {}
    
    // operator() is NOT const
    void operator()() { 
        x++; // Succeeds. Modifies the closure's internal copy of 'x'
    }
};

​

Technical Characteristics and Edge Cases

1. State Persistence: Because mutable modifies the member variables of the closure object itself, the mutated state persists across multiple invocations of the same lambda instance.

int val = 0;
auto counter = [val]() mutable { return ++val; };

counter(); // returns 1
counter(); // returns 2

2. Isolation from Enclosing Scope: Mutating a by-value capture only alters the closure object’s internal copy. The original variable in the enclosing scope remains completely unchanged.
3. Top-Level const Variables: If a variable is declared with a top-level const in the enclosing scope, capturing it by value copies the const qualifier directly to the closure’s internal data member. In this scenario, applying mutable strips the const from operator(), but the internal variable itself remains a const type and cannot be modified.

const int y = 10;
auto edge_case = [y]() mutable {
    // y++; // ERROR: 'y' is still a const int inside the closure
};

4. Irrelevance to Reference Captures: The mutable keyword has no practical effect on variables captured by reference ([&], [&x]). A reference capture allows modification of the original variable regardless of whether the lambda is mutable, because the const qualification of the default operator() applies to the reference itself (which is inherently immutable in what it points to), not the referenced data.