8

This seems strange, I can capture the static variable, but only if the variable isn't specified in the capture list, i.e., it implicitly captures it.

int main()
{
    int captureMe = 0;
    static int captureMe_static = 0;

    auto lambda1 = [&]() { captureMe++; };  // Works, deduced capture
    auto lambda2 = [&captureMe]() { captureMe++; }; // Works, explicit capture
    auto lambda3 = [&] () { captureMe_static++; };  // Works, capturing static int implicitly
    auto lambda4 = [&captureMe_static] { captureMe_static++; }; // Capturing static in explicitly:  
                                                                // Error: A variable with static storage duration 
                                                                // cannot be captured in a lambda

    // Also says "identifier in capture must be a variable with automatic storage duration declared
    // in the reaching scope of the lambda

    lambda1(); lambda2(); lambda3();    // All work fine

    return 0;
}

I'm not understanding, the third and fourth captures should be equivalent, no? In the third I'm not capturing a variable with "automatic storage duration"

Edit: I think the answer to this is that it is never capturing the static variable, so:

auto lambda = [&] { captureMe_static++; };   // Ampersand says to capture any variables, but it doesn't need to capture anything so the ampersand is not doing anything
auto lambda = [] { captureMe_static++; };  // As shown by this, the static doesn't need to be captured, and can't be captured according to the rules.
Evg
  • 25,259
  • 5
  • 41
  • 83
Zebrafish
  • 11,682
  • 3
  • 43
  • 119

2 Answers2

17

A variable with static storage duration doesn't need to be captured, and, therefore, cannot be captured. You can simply use it within the lambda.

With automatic variables there is an issue: while in other languages a closure would simply store a reference to the variable in the enclosing scope, in C++ a lambda does not have the ability to extend the lifetime of an automatic variable, which might therefore go out of scope, leaving behind a dangling reference in the lambda. For this reason C++ allows you to choose whether to capture an automatic variable by copy or by reference. But if the variable is static then this issue does not arise; the lambda will simply behave as though it has captured it by reference.

If you do want to capture a static variable by value then use the C++14 init-capture syntax.

Brian Bi
  • 111,498
  • 10
  • 176
  • 312
  • 1
    "doesn't need to be captured, and, therefore, cannot be captured." I don't see a logic here. Why prohibit explicit static vars capturing if it seamlessly fits in C++ language rules – Alexey Andronov Aug 29 '17 at 04:11
  • 1
    @sfk92fksdf I couldn't tell you. Someone on the committee might know the answer. – Brian Bi Aug 29 '17 at 04:14
  • 2
    @sfk92fksdf There is the answer you are looking for: https://stackoverflow.com/a/13828144/2865757 – Zefick Aug 29 '17 at 05:13
  • 1
    @Zefick, thanks, that's also an actual answer to OP's question %) – Alexey Andronov Aug 29 '17 at 05:24
  • 1
    When made a lambda with an empty capture list, I was able to access the static variable, so it's true you don't have to capture it. So I guess, in the case where I did [&] and was able to access the static variable, it wasn't capturing it, it just have access to it. – Zebrafish Aug 29 '17 at 07:23
0

Isn't this what you wanted?

static int dont_capture_me = 0;

auto foo = [] { dont_capture_me++; };

Of course, you can explicitly store a reference, but they are essentially equivalent.

auto bar = [&reference = dont_capture_me] { reference++; };
WindyFields
  • 2,697
  • 1
  • 18
  • 21