When a C ++ lambda expression has many records by reference, the size of an object with an unnamed function becomes large

Question

The following code:

int main() {
    int a, b, c, d, e, f, g;
    auto func = [&](){cout << a << b << c << d << e << f << g << endl;};
    cout << sizeof(func) << endl;
    return 0;
}

outputs 56 compiled with g ++ 4.8.2

Since all local variables are stored in the same stack stack, remembering one pointer is enough to find the addresses of all local variables. Why does a lambda expression build such a large unnamed function object?

Answer 1

I do not understand why you are surprised.

The C ++ standard provides a set of requirements, and each individual implementation can choose any strategy that meets the requirements.

Why does the implementation optimize the size of the lambda object?

, , ?

, ! !, , . , ...

... , :

struct S { int a, b, c, d, e, f, g; };

int main() {
    S s = {};
    auto func = [&](){
        std::cout << s.a << s.b << s.c << s.d << s.e << s.f << s.g << "\n";
    };
    std::cout << sizeof(func) << "\n";
    return 0;
}

: 4 !

Answer 2

. ( , ).

++ -, , , , .

, , , " " ++-. this, , - bog-standard operator(). " " ++- , " " ..

-, , , . ( ), . , , , , , .

- . , void*, . , , ( undefined). , , ( , , ) lambdas .

. , , . , , . , , .

, .

Answer 3

. , , , , , - .

There would be nothing wrong with compiling one pointer and using offsets to do what you propose as an optimization. Perhaps some compilers do this, I don't know.