When is 'this' captured in a lambda?

Question

I have a function in a class that defines a lambda and stores it in a local static variable:

class A { public:     void call_print()     {         static auto const print_func = [this] {             print();         };          print_func();     };      virtual void print()     {         std::cout << "A::print()\n";     } };  class B : public A { public:     virtual void print() override     {         std::cout << "B::print()\n";     } }; 

I also execute the following test:

int main() {     A a;     B b;      a.call_print();     b.call_print(); } 

(Live Sample)

What I expect to be printed is:

A::print() B::print() 

But what I really get is:

A::print() A::print() 

(Same object address is also printed with each)

I suspect this is due to the this capture. I assumed that it would capture the value of this when it is called, however it seems to be captured the moment the lambda is defined.

Could someone explain the semantics of lambda captures? When do they actually get provided to the function? Is it the same for all capture types, or is this a special case? Removing static fixes the problem, however in my production code I'm actually storing the lambda in a slightly-heavier object which represents a slot to which I insert into a signal later.

Answer 1

This has nothing to do with the semantics of lambda capture. It's simply how static works.

A static function-scoped variable is initialized exactly once. There is only ever one such object in your entire program. It will be initialized the first time the function is called (more specifically, the first time the static statement is executed). And therefore, the expression used to initialize the static variable is only ever invoked once.

So if a static function-scoped variable is initialized with data that's based on one of the function's parameters (like this), then it will only get the parameters from the first invocation of that function.

Your code creates a single lambda. It does not create different lambdas on each invocation of the function.

The behavior you seem to want is not a function-local static variable, but an object member. So just put a std::function object in the class itself, and have call_print initialize it if it is empty.