C++ Lambdas

In this lesson, we introduce Lambdas. They provide a more concise syntax for creating functions. Lambdas give us more options for designing our software, as they have two key differences compared to regular functions:

• They can be defined almost anywhere - including within the bodies of other functions
• They can be anonymous - we don't need to give them a name

This makes lambdas the default choice for scenarios where we need simple, one-off functions. For example, if we need a function to pass as the parameter of another function, lambdas are often the default choice.

This is because they make our code faster to write, and more readable. The lambda is defined at the same place it is being used and, if the lambda is used only in that place, we don't need to clutter our code with unnecessary identifiers.

A lambda expression looks like this:

1[] () {
2  std::cout << "Hello from Lambda!";
3}
4

By itself, the expression doesn't do anything. However, we can treat it like any other expression - for example, we call a lambda directly using ():

1[] () {
2  std::cout << "Hello from Lambda!";
3}();
4

We can store the lambda as a variable, and can then call it through that variable later:

1auto MyLambda { [] () {
2  std::cout << "Hello from Lambda!";
3} };
4
5MyLambda();
6

However, by far the most common use of a lambda is to pass it to another function:

1// Function that accepts a function argument
2void CallIfEven(int Num, auto FunctionToCall) {
3  if (Num % 2 == 0) {
4      FunctionToCall();
5  }
6}
7
8int main() {
9  // Passing a lambda to that function
10  CallIfEven(4, []() {
11    std::cout << "It's even!"
12  })
13}
14

Lambda Parameters

Between the ( and ) of a lambda expression, we can specify parameters in the normal way:

1[](int x, int y){
2  std::cout << "The total is " << x+y;
3};
4

We have access to all the same techniques as functions, including passing by reference and using const:

1[](const int& x, const int& y){
2  std::cout << "The total is " << x+y;
3};
4

We also pass arguments into those parameters in the usual way, within the ( and ) when we call our lambda:

1auto MyLambda { [](int x, int y){
2  std::cout << "The total is " << x+y;
3} };
4
5MyLambda(2, 5);
6

When a lambda’s parameter list is empty (i.e., it doesn’t accept any arguments), we have the option of removing it entirely, including the ( and ):

1auto SayHello { []{
2  std::cout << "Hello!";
3} };
4
5SayHello();
6

Lambda Return Types and Values

By default, the compiler infers the return type of the lambda. This is equivalent to having a function with an auto return type:

1// This will return a boolean
2[](int Number){
3  return Number % 2 == 0;
4};
5

We may want to explicitly set the return type of our lambda. This would behave the same as setting the return type of a regular function. For example, return values will be implicitly cast to the return type we specify.

The syntax for specifying the return type of a lambda looks like this:

1[](int Number) -> bool {
2  return Number % 2 == 0;
3};
4

Lambda Captures

Normally, we are able to access values from the parent scope. However, this does not work with lambdas. The following code will not compile:

1int main() {
2  int Number { 2 };
3
4  []() {
5    Number++;
6  }();
7
8  std::cout << "Number is " << Number;
9}
10

To give our lambda access to variables within the scope it is defined, we need to “capture” them.

The [] in a lambda expression is where we capture variables from the parent scope we want to use.

1int main() {
2  int x { 1 };
3  int y { 1 };
4
5  [x, y]() {
6    x++;
7    y++;
8  }();
9
10  std::cout << "Total is " << x + y;
11}
12

Our code now compiles. However, it logs out 2, rather than the 4 we might have expected. This is because, just like parameters, captures are passed by value.

So, we’re incrementing copies of x and y rather than the original variables. We can capture by reference using the & character:

1int main() {
2  int x { 1 };
3  int y { 1 };
4
5  [&x, &y]() {
6    x++;
7    y++;
8  }();
9
10  std::cout << "Total is " << x + y;
11}
12

Our code will now log out 4

const and mutable with Lambda Captures

When capturing const values, we will not be able to modify them:

1int main () {
2  const int x { 1 };
3  [x]() {
4    // Error - x is const
5    x++;
6  }
7}
8

This can be quite restrictive when passing by value as in that scenario, what we're trying to modify isn't x, rather it is a copy of x.

Marking our lambda as mutable works around this:

1int main () {
2  const int x { 1 };
3  [x]() mutable {
4    x++;
5  }
6}
7

We are able to create new variables in the capture clause. This is useful mainly for concisely capturing variables from the parent scope, whilst simultaneously performing simple modifications.

A common use case is when capturing references that we want to declare as const within the lambda. The standard library's utility header includes the std::as_const function to help with this:

1#include <utility>
2
3int main () {
4  int x { 1 };
5
6  [&x = std::as_const(x)]() {
7    // Error - x is const in this lambda
8    x++;
9  }
10}
11

Default Capture

For simpler use cases, the compiler can help us create our capture list. It knows what variables we’re using in our lamda, so it can automatically capture them for us.

We can ask it to capture everything we use by value, using the = symbol in our capture group:

1int main () {
2  int x { 1 };
3
4  [=]() {
5    x++;
6  }
7}
8

To capture everything by reference, we can use &:

1int main () {
2  int x { 1 };
3
4  [&]() {
5    x++;
6  }
7}
8

We can mix and match these techniques as needed. If we’re using a default capture, it needs to be first:

1// Capture x by reference
2// Capture y by const reference
3// Capture everything else by value
4[=, &x, &y = std::as_const(y)]() {
5  // ...
6}
7