CODEWITHSUNDEEP
c++lambda
Ajay yadav
Ajay yadav

Reputation: 4511

Disadvantage of using lambda default capture by value or reference in C++11?

What are the pitfalls of using lambda default capture by value ([=]) or by reference ([&]) in C++11?

I know some pitfalls like:

Does default capturing by value have any disadvantages?

Upvotes: 11

Views: 6160

Answers (4)

MikeMB
MikeMB

Reputation: 21156

I think the dangling reference problem you mentioned is the main pitfall.

One other thing that is sometimes overlooked however, is that even when one uses a capture-by-value-lambda in a member function, it doesn't create a copy of the used member variables, but only makes a copy of the this pointer.

For one, this means that you are again open to the dangling pointer Problem and second, you might accidentally modify variables outside of the scope of the lambda, even when it looks like, you are only modifying a local copy.

E.g. this will print 0 1 1 instead of 0 1 0 

struct Foo {
    int bar=0;
    int bas() {
        auto inc = [=]() {          
            bar++;  //this is equivalent to this->bar++ 
            return bar; 
        };
        return inc();
    }
};

int main() {
    Foo foo;
    std::cout << foo.bar <<" ";
    std::cout << foo.bas() << " ";
    std::cout << foo.bar << std::endl; 
}

EDIT: Just to avoid confusion related to the point made by @Snps:
If bar was a local variable in bas() (and thus be captured by value), the above lambda would not compile, as by-value-captured-variables are by default const, unless you explicitly specify the lambda as mutable. So if you think about it, it is clear that bar is not copied, but that's easily forgotten, when reading or writing code.

Upvotes: 12

Felix Glas
Felix Glas

Reputation: 15524

Capturing by value using [=] or [<identifier>] has the effect of creating a lambda member of the exact same type as the captured entity, including constness, e.g., when capturing a const int by value, the resulting member can not be mutated even when the lambda call operator is mutable.

const int i = 1;
[=] () mutable { ++i; }(); // Error: increment of read-only variable.

This can be worked around using C++14's initializing capture expressions:

[i = i] () mutable { ++i; }(); // Ok

Upvotes: 5

Basile Starynkevitch
Basile Starynkevitch

Reputation: 1

Capturing by values involve copying the closed values, so might mean more memory consumption and more processing for that copy.

Upvotes: 2

Bill Lynch
Bill Lynch

Reputation: 81926

It has exactly the same advantages and disadvantage as a comparison between:

int value(const T x) { ... }
int value(T& x) { ... }

Upvotes: 5

Related Questions