在没有捕获列表的情况下访问lambda中的变量

Question

I wonder why I can use global variables (thanks to Chris Drew for correcting me) in lamdas and why I don't need to capture them:

#include <iostream>
#include <vector>
using namespace std;

size_t i = 0;
vector<int> v = {1,2,3};

int main()
{
    auto lambda = [](){i = v.size();};
    lambda();
    cout << i << endl;

    return EXIT_SUCCESS;
}

In this minimum working example I am accessing the size_t and the vector without capturing them. I would have to if they were declared inside the main-method. Why is that so and how can I copy the size_t and the vector? I tried to use [=] as capture list but it does not copy v and i .

Answer 1

One way to capture a global variable by value is to use C++14 generalized lambda captures :

#include <iostream>
#include <vector>

size_t i = 0;
std::vector<int> v = {1,2,3};

int main() {
    auto lambda = [myi = i, myv = v]()mutable{myi = myv.size();};
    lambda();
    std::cout << i << std::endl;
}

Live demo.

Answer 2

In your case i and v are global variable, accessible to the whole TU.

As you asked how to capture them by value, I think you should be able to capture them using both [=] or listing the variables [i, v] , but this would lead to an error, because they will be read-only and you are assigning to i inside the lambda body.

Option 1:
capture i by ref and v by value (if that makes sense at all...):

#include <iostream>  
#include <vector>  
using namespace std;
int main() {
    size_t i = 0;
    vector<int> v = {1,2,3};
    auto lambda = [&i,v](){i = v.size();};
    lambda();
    cout << i << endl;

    return EXIT_SUCCESS; }

http://ideone.com/fkn4za

Option 2:
use a mutable lambda and capture both by value (this makes even less sense).
Ie see this question on SO .
Please note that in this case also i will be captured by value, thus the global i will not be assigned, remaining at value == 0.

http://ideone.com/qwlFVv

Answer 3

Lambdas have accesses to global variables, and static variables in a class without explicitly capturing them. If it were a local variable, then you program would be ill-formed.

#include <iostream>
#include <vector>
using namespace std;
int main()
{
    size_t i = 0;
    vector<int> v = {1,2,3};
    auto lambda = [](){i = v.size();};   //Error, 
    lambda();
    cout << i << endl;

    return EXIT_SUCCESS;
}

As seen here

Same with static variables in a class:

#include <iostream>
#include <vector>
using namespace std;

struct S{
    void touch(){ []{ k = 89; }(); }
    static int getK(){ return k; }
private:
    static int k;
};

int S::k = 0;


int main()
{
    S s;
    std::cout << S::getK() << std::endl;
    s.touch();
    std::cout << S::getK() << std::endl;
}

As seen Here

Answer 4

Your lambda is basically converted to a functor, it's the same as :

#include <iostream>
#include <vector>
using namespace std;

size_t i = 0;
vector<int> v = {1,2,3};

struct lambda
{
  void operator()() { i = v.size(); }
};

int main()
{
    lambda x;
    x();
    cout << i << endl;

    return EXIT_SUCCESS;
}

As you can see, lambda can perfectly access any global variable, it's even in their name, the variable is globally accessible.

If i and v were local to main() then we'd have an issue and we'd have to capture them.