Creating Stateful Lambdas

Yes, it's possible to create a lambda that maintains state across multiple invocations. This is achieved by capturing variables by reference.

Here's an example:

1#include <iostream>
2
3int main() {
4  int counter{0};
5
6  auto IncrementCounter{[&counter]() {  
7    ++counter;
8    std::cout << "Counter: " << counter << '\n';
9  }};
10
11  IncrementCounter();
12  IncrementCounter();
13  IncrementCounter();
14}

1Counter: 1
2Counter: 2
3Counter: 3

In this code, counter is a local variable in main. We create a lambda IncrementCounter that captures counter by reference.

Inside the lambda, we increment counter and print its value. Because counter is captured by reference, any changes made to it inside the lambda are reflected outside the lambda.

Each time IncrementCounter is called, it increments and prints the same counter variable. Thus, the output shows the counter increasing with each invocation.

This technique can be used to create lambdas that maintain internal state, similar to a small function object.

However, it's important to be careful with this technique. If the captured reference outlives the original variable, you'll have a dangling reference and undefined behavior. For example:

1auto MakeLambda() {
2  int counter{0};
3  return [&counter]() {
4    ++counter;
5  };
6}
7
8int main() {
9  auto Lambda{MakeLambda()};
10  Lambda(); // Undefined behavior
11}

Here, counter is a local variable in MakeLambda. The lambda captures it by reference and is then returned from the function. However, when MakeLambda ends, counter is destroyed. Thus, when we later call Lambda, it's referencing a variable that no longer exists.

To avoid this, you can capture by value instead of by reference. This creates a copy of the variable that the lambda owns, avoiding dangling references:

1auto MakeLambda() {
2  int counter{0};
3  return [counter]() mutable {
4    ++counter;
5  };
6}

Note that we need to mark the lambda as mutable in this case, as we're modifying a captured value.