20

I seems to miss some point in lambda mechanism in C++. Here is the code:

std::vector<int> vec (5);

int init = 0;
std::generate(begin(vec), end(vec), [init]() mutable { return ++init; });

for (auto item : vec) {
    std::cout << item << " ";
}
std::cout << std::endl << init << std::endl;

If there is no mutable it wouldn't compile because I'm changing init in lambda.
Now, as I understand lambda is called for each vector's item with a new fresh copy of init which is 0. So, 1 must be returned every time. But the output of this piece of code is:
1 2 3 4 5
0

It looks like generate captures by copy init only once at the beginning of its execution. But why? Is it supposed to work like this?

Improve this question
3
  • That's exactly how its supposed to work Commented May 14, 2016 at 0:46
  • 1
    You'd probably get what you are describing if you used a for loop and in the body of the loop you did something like vec[i] = ([init] () mutable {return ++init;})();, because this creates one lambda function every iteration. Commented May 14, 2016 at 9:36
  • @Bakuriu. That was my point of confusion - I thought that for loop and generate(begin, end, lambda) should do the same thing. Commented May 16, 2016 at 19:48

5 Answers 5

Reset to default
33

Now, as I understand lambda is called for each vector's item with a new fresh copy of init which is 0.

That is not correct. A lambda is just a another way to make a class and provide an operator() for it. The [] part of the lambda describes the member variables and whether they are captured by reference or value. The () part of the lambda is the parameter list for the operator() and the {} part is the body of that function. The mutable part tells the compiler to make the operator() non const as it is const by default.

So

[init]() mutable { return ++init; }

Becomes

struct compiler_generated_name
{
    int init; // we captured by value

    auto operator()() // since we used mutable this is non const
    {
        return ++init;
    }
};

I used a struct here for brevity of typing but a lambda is specified as a class type so class could be used.

This means the init is the same init from the last iteration as you only ever capture once. This is important to remember as

auto generate_lambda()
{
    int foo = 0;
    return [&foo](){ return ++foo; };
}

Will leave you with a dangling reference to foo when the function returns and using it is undefined behavior.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

This is the best/simplest explanation that I've seen for implementing lambda expressions. Thanks!
10

The lambda is a compiler-generated struct equivalent to:

struct lambda
{
    int init = 0; // captured value

    auto operator()() // non-const, due to `mutable`
    {
        return ++init;
    }
};

Therefore, init is captured and copied inside the lambda just once - calling the lambda multiple times will not capture init again.

Improve this answer

Comments

5

You are coping and seeing the initial value of init -- what you you probably want to do acording to what you expect is to capture init by reference.....

std::vector<int> vec (5);

int init = 0;
std::generate(begin(vec), end(vec), [&init]() mutable { return ++init; });

for (auto item : vec) {
    std::cout << item << " ";
}
std::cout << std::endl << init << std::endl;
Improve this answer

8 Comments

I used it many times with [&param] and know how it works. This is just an example code which I run after read about mutable applied to lambdas
How does this explain why an increasing list of values was generated and how does capturing by reference fix that?
@NathanOliver: Is it a test for me?))
@IgorStack No. I am asking Soren as I don not understand what question he is trying to answer.
I was explaining why the last line of output was 0 -- somehow thought that was the question.
|
3

Your error is here "Now, as I understand lambda is called for each vector's item with a new fresh copy of init which is 0" (my italics). No; as you can see the lambda is completely separate, and therefore ignorant, of the vector code. The initialisation of item takes place each time the lambda form itself is evaluated (as opposed to each time the resulting value is called); here this means each time the function generate is called: just once.

Improve this answer

Comments

1 
int x = ([](int j)->int {return j; }, 3);
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.