Chapter 73: Lambdas

// the lambda.

Modifying can be allowed by using the keyword mutable, which make the closer object's operator() non-const:

auto func = [c = 0]() mutable {++c; std::cout << c;};

If used together with the return type, mutable comes before it.

auto func = [c = 0]() mutable -> int {++c; std::cout << c; return c;};

An example to illustrate the usefulness of lambdas

Before C++11:

Version < C++11

// Generic functor used for comparison struct islessthan

{

islessthan(int threshold) : _threshold(threshold) {}

bool operator()(int value) const

{

return value < _threshold;

}

private:

int _threshold;

};

// Declare a vector

const int arr[] = { 1, 2, 3, 4, 5 }; std::vector<int> vec(arr, arr+5);

// Find a number that's less than a given input (assume this would have been function input) int threshold = 10;

std::vector<int>::iterator it = std::find_if(vec.begin(), vec.end(), islessthan(threshold));

Since C++11:

Version ≥ C++11

// Declare a vector

std::vector<int> vec{ 1, 2, 3, 4, 5 };

// Find a number that's less than a given input (assume this would have been function input) int threshold = 10;

auto it = std::find_if(vec.begin(), vec.end(), [threshold](int value) { return value < threshold; });

Section 73.2: Specifying the return type

For lambdas with a single return statement, or multiple return statements whose expressions are of the same type, the compiler can deduce the return type:

// Returns bool, because "value > 10" is a comparison which yields a Boolean result auto l = [](int value) {

return value > 10;

}

For lambdas with multiple return statements of di erent types, the compiler can't deduce the return type:

// error: return types must match if lambda has unspecified return type auto l = [](int value) {

if (value < 10) { return 1;

} else { return 1.5;

}

};

In this case you have to specify the return type explicitly:

// The return type is specified explicitly as 'double' auto l = [](int value) -> double {

if (value < 10) { return 1;

} else { return 1.5;

}

};

The rules for this match the rules for auto type deduction. Lambdas without explicitly specified return types never return references, so if a reference type is desired it must be explicitly specified as well:

auto copy = [](X& x) { return x; }; // 'copy' returns an X, so copies its input auto ref = [](X& x) -> X& { return x; }; // 'ref' returns an X&, no copy

Section 73.3: Capture by value

If you specify the variable's name in the capture list, the lambda will capture it by value. This means that the generated closure type for the lambda stores a copy of the variable. This also requires that the variable's type be copy-constructible:

int a = 0;

[a]() {

return a; // Ok, 'a' is captured by value

};

Version < C++14

auto p = std::unique_ptr<T>(...);

[p]() { // Compile error; `unique_ptr` is not copy-constructible return p->createWidget();

};

From C++14 on, it is possible to initialize variables on the spot. This allows move only types to be captured in the lambda.

Version ≥ C++14

auto p = std::make_unique<T>(...);

[p = std::move(p)]() {

return p->createWidget();

};

Even though a lambda captures variables by value when they are given by their name, such variables cannot be modified within the lambda body by default. This is because the closure type puts the lambda body in a declaration of operator() const.