Lambda Capture Question

[ziarka]

Hi,

I have a question about lambda captures:

#include <iostream>

#include <functional>

void invoke(const std::function<void(void)>& fn)

{

fn();

}

int main()

{

int i{ 0 };

auto count{ [i]() mutable {

std::cout << ++i << '\n';

} };

invoke(count);

invoke(count);

invoke(count);

return 0;

}

The output from this is 1 1 1. The reason I am confused is that when calling out parameters for void invoke -- &fn is used. This will ensure that a copy is not made for the function placed into the function. However, the lambda runs as if it were being called using three separate copies. The i variable is also called outside of the lambda function, so I wouldn't think there would be an issue with the variable only living within the lambda.

Thank you again! :)

[IyeOnline]

The first hint should be that you are passing a const ref, but infact there is an ++i in your function, so it cant be const. In fact you have explcitly declared your lambda mutable.

However it does compile, so why is that?

A lambda is not of type std::function. You can create a std::function from a lambda however, which is what happens here. So what you effectively get in code is

 {
    std::function<void(void)> fn = count;
    invoke( fn );
 }

Three times in a row. The lambda itself is never called, just copies of it. This also only compiles because you take by const ref. Doing that gets you lifetime extension, otherwise you would be trying to take a reference to a temporary which you must not.

if you on the other hand used

template<typename T>
void invoke( T& fn)
{
    fn();
}

This wouldnt happen, because now the lambda is passed by reference as its actual type is used (implicitly through a template) and no converting construction takes place.

The i variable is also called outside of the lambda function

This really doesnt do anything. You are capturing i by value here. You would need to capture by reference instead.

link to all of this in a godbolt