4

Does the standard define what happens with this code?

#include <iostream> template <typename Func> void callfunc(Func f) { ::std::cout << "In callfunc.\n"; f(); } template <typename Func> void callfuncref(Func &f) { ::std::cout << "In callfuncref.\n"; f(); } int main() { int n = 10; // n is captured by value, and the lambda expression is mutable so // modifications to n are allowed inside the lambda block. auto foo = [n]() mutable -> void { ::std::cout << "Before increment n == " << n << '\n'; ++n; ::std::cout << "After increment n == " << n << '\n'; }; callfunc(foo); callfunc(foo); callfuncref(foo); callfunc(foo); return 0; }

The output of this with g++ is:

$ ./a.out In callfunc. Before increment n == 10 After increment n == 11 In callfunc. Before increment n == 10 After increment n == 11 In callfuncref. Before increment n == 10 After increment n == 11 In callfunc. Before increment n == 11 After increment n == 12

Are all features of this output required by the standard?

In particular it appears that if a copy of the lambda object is made, all of the captured values are also copied. But if the lambda object is passed by reference none of the captured values are copied. And no copies are made of a captured value just before the function is called, so mutations to the captured value are otherwise preserved between calls.

Improve this question

3 Answers 3

Reset to default
9

The type of the lambda is simply a class (n3290 §5.1.2/3), with an operator() which executes the body (/5), and an implicit copy constructor (/19), and capturing a variable by copy is equivalent to copy-initialize (/21) it to a non-static data member (/14) of this class, and each use of that variable is replaced by the corresponding data member (/17). After this transformation, the lambda expression becomes only an instance of this class, and the general rules of C++ follows.

That means, your code shall work in the same way as:

int main() { int n = 10; class __Foo__ // §5.1.2/3 { int __n__; // §5.1.2/14 public: void operator()() // §5.1.2/5 { std::cout << "Before increment n == " << __n__ << '\n'; ++ __n__; // §5.1.2/17 std::cout << "After increment n == " << __n__ << '\n'; } __Foo__() = delete; __Foo__(int n) : __n__(n) {} //__Foo__(const __Foo__&) = default; // §5.1.2/19 } foo {n}; // §5.1.2/21 callfunc(foo); callfunc(foo); callfuncref(foo); callfunc(foo); }

And it is obvious what callfuncref does here.

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

2 Comments

Do these lambda-equivalent classes also have move constructors and move assignment operations?
@Omnifarious: Move constructors: "Maybe" (§5.1.2/19: "and may have an implicitly-declared move constructor"). The lambda does not have any assignment operators, they are deleted.
4

I find it easiest to understand this behaviour by manually expanding the lambda to a struct/class, which would be more or less something like this (as n is captured by value, capture by reference would look a bit different):

class SomeTemp { mutable int n; public: SomeTemp(int n) : n(n) {} void operator()() const { ::std::cout << "Before increment n == " << n << '\n'; ++n; ::std::cout << "After increment n == " << n << '\n'; } } foo(n);

Your functions callfunc and callfuncref operate more or less on objects of this type. Now let us examine the calls you do:

callfunc(foo);

Here you pass by value, so foo will be copied using the default copy constructor. The operations in callfunc will only affect the internal state of the copied value, no state changed in the actual foo object.

callfunc(foo);

Same stuff

callfuncref(foo);

Ah, here we pass foo by reference, so callfuncref (which calls operator()) will update the actual foo object, not a temporary copy. This will result in n of foo being updated to 11 afterwards, this is regular pass-by-reference behaviour. Therefore, when you call this again:

callfunc(foo);

You will again operate on a copy, but a copy of foo where n is set to 11. Which shows what you expect.

Improve this answer

1 Comment

In a different question where I wasn't so concerned with exactly what the standard said, I would've considered your answer the better answer. :-)
2

The value is captured by copy unless you explicitly capture-all [&] or capture a specific variable by reference [&n]. So the whole output is Standard.

Improve this answer

1 Comment

I'm particularly interested in callfuncref. This is more about the mutability of the captured value than whether capture by value or reference is default.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.