In C++, a lambda expression is an anonymous function that can be defined inline, without the need for a separate function declaration. Stateful lambda expressions, also known as closures, are lambda expressions that capture and store values from their enclosing scope. These values are then available to the lambda expression when it is executed.

To create a stateful lambda expression in C++, you first define the lambda expression itself using the following syntax:

[capture-list](arguments) mutable(optional) -> return-type { 
    // lambda body
}

The capture list is used to specify which variables from the enclosing scope should be captured and made available to the lambda expression. The syntax for the capture list is as follows:

[capture1, capture2, ...]

You can capture variables by value or by reference. To capture a variable by value, use the syntax [=] and to capture by reference use the syntax [&]. For example, to capture a variable x by value, you can use the following syntax:

int x = 10;
auto lambda = [x]() {
    std::cout << "x = " << x << std::endl;
};

In this example, the lambda expression captures the variable x by value and stores it inside the lambda expression. When the lambda expression is executed, it will print the value of x.

You can also capture multiple variables by value or by reference, as shown in the following example:

int x = 10;
int y = 20;
auto lambda = [&x, y]() {
    x++;
    y++;
    std::cout << "x = " << x << ", y = " << y << std::endl;
};

In this example, the lambda expression captures the variable x by reference and y by value. When the lambda expression is executed, it increments the value of x and y, and then prints their new values.

Note that by default, variables captured by value are read-only inside the lambda expression. If you want to modify these variables, you need to use the mutable keyword. For example:

int x = 10;
auto lambda = [x]() mutable {
    x++;
    std::cout << "x = " << x << std::endl;
};

In this example, the mutable keyword is used to allow the lambda expression to modify the value of x.

Overall, stateful lambda expressions provide a powerful way to create anonymous functions that can capture and store values from their enclosing scope, making it easy to write more concise and expressive code.