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 needing 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.

Lambda Expressions

A minimalist lambda expression uses a set of square brackets, [], followed by a code block, {}. Between the { and }, we implement the behaviors our lambda will perform.

In this example, we create a lambda that does some logging:

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

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

1#include <iostream>
2
3int main() {
4  []{
5    std::cout << "Hello from Lambda!";
6  }();
7}

1Hello from Lambda!

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

1#include <iostream>
2
3int main() {
4  auto MyLambda { []{
5    std::cout << "Hello from Lambda!";
6  }};
7
8  MyLambda();
9}

1Hello from Lambda!

However, by far the most common use of a lambda is to pass it to another function. Below, our CallIfEven() function accepts an integer and a callback. If the integer is even, the callback will be invoked.

In previous lessons, we saw how we could provide such a callback using a function pointer or a functor. But, these constructs require us to define a function or a type elsewhere in our code.

If we just need a simple callable to implement some behavior, using a lambda is the best choice:

1#include <iostream>
2
3void CallIfEven(int Num, auto Callback) {
4  if (Num % 2 == 0) {
5    Callback();
6  }
7}
8
9int main() {
10  CallIfEven(4, [] {
11    std::cout << "4 is even";
12  });
13}

14 is even

Using Parameters

To allow our lambda to accept parameters, we can introduce a set of parenthesis, ( and ) to the basic lambda structure.

Below, we provide an alternative way to define a lambda:

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

This lambda still accepts no parameters, but we can now provide a parameter list within the ( and ). This parameter list works like any other function.

Below, we define a lambda that accepts two int arguments:

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

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};

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

1#include <iostream>
2
3int main() {
4  auto MyLambda { [](int x, int y){
5    std::cout << "The total is " << x + y;
6  }};
7
8  MyLambda(2, 5);
9}

1The total is 7

Specifying Return Types

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};

We may want to explicitly set the return type of our lambda. If we wanted to explicitly set the return type to be a bool, the syntax looks like the following:

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

This has the same effect as specifying a return type on a regular function. Specifically, if we attempt to return something that does not have that type, the compiler will attempt to implicitly convert it.

For example, the body of the following lambda attempts to return an int, but because we’ve specified the lambda’s return type as bool, our return value will be converted to a boolean. In this case, our lambda will return true:

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

When specifying a return type, we must include a parameter list using ( and ), even if it is empty:

1[]() -> bool {
2  return true;
3};

Capturing Variables

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

1#include <iostream>
2
3int main() {
4  int Number{2};
5
6  [] {
7    std::cout << "Number: " << Number;
8  };
9}

1error C3493: 'Number' cannot be implicitly captured because no default capture mode has been specified
2error C2326: lambda function cannot access 'Number'

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:

1#include <iostream>
2
3int main() {
4  int Number{2};
5
6  [Number] {
7    std::cout << "Number: " << Number;  
8  };
9}

1Number: 2

We can capture multiple objects by separating them with commas:

1#include <iostream>
2
3int main() {
4  int x{1};
5  int y{2};
6  int z{3};
7
8  [x, y, z] { 
9    std::cout << "Sum: " << x + y + z;
10  }();
11}

1Sum: 6

Modifying Captures

We can create new variables in the capture clause. This is useful mainly for performing subtle modifications to what we’re capturing. For example, we can give our captures different names, or cast them:

1#include <iostream>
2
3int main() {
4  int x{1};
5
6  [Value = x, Casted = static_cast<bool>(x)] {  
7    std::cout << "Value: " << Value << '\n';
8    std::cout << "Casted type: "
9      << typeid(Casted).name();
10  }();
11}

1Value: 1
2Casted type: bool

mutable Lambdas

By default, lambdas capture objects by const value. This means that the objects we capture are copied into our lambda, and we are then prevented from modifying them:

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

1error C3491: a by copy capture cannot be modified in a non-mutable lambda

To allow modification of these copies, we can mark our lambda as mutable. Applying the mutable keyword requires us to include the parameter list syntax (), even if it is empty:

1#include <iostream>
2
3int main() {
4  int Number{2};
5
6  [Number]() mutable {  
7    std::cout << "Number in Lambda: "
8      << ++Number;
9  }();
10}

1Number in Lambda: 3

1#include <iostream>
2
3int main() {
4  int Number{2};
5
6  auto Lambda{[Number]() mutable {
7    std::cout << "Number in Lambda: "
8      << ++Number << '\n';
9  }};
10
11  Lambda();
12  Lambda();
13  Lambda();
14  std::cout << "Number in main: " << Number;
15}

1Number in Lambda: 3
2Number in Lambda: 4
3Number in Lambda: 5
4Number in main: 2

Capturing by Reference

Similar to parameters, we can elect to capture objects by reference instead of by value. We do this by prepending & to the identifiers:

1#include <iostream>
2
3int main() {
4  int Number{2};
5
6  [&Number] {  
7    ++Number;
8  }();
9
10  std::cout << "Number: " << Number;
11}

1Number: 3

Capturing by const Reference

When we want to capture an object by reference, and also mark that reference as const, the std::as_const() function within the <utility> header can help us:

1#include <utility>
2
3int main() {
4  int x{1};
5
6  [&x = std::as_const(x)] {
7    x++;  
8  };
9}

1error: increment of read-only reference 'x'

Default Captures

For simpler use cases, the compiler can help us create our capture list. It knows what variables we’re using in our lambda, 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:

1#include <iostream>
2
3int main () {
4  int x { 1 };
5
6  [=] {
7    std::cout << "x: " << x;
8  }();
9}

1x: 1

To capture everything by reference, we can use &:

1#include <iostream>
2
3int main () {
4  int x { 1 };
5
6  [&] { ++x; }();
7
8  std::cout << "x: " << x;
9}

1x: 2

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

1#include <iostream>
2
3int main() {
4  int x{1};
5  int y{2};
6  int z{3};
7
8  // Capture x by reference
9  // Capture y by const reference
10  // Capture everything else by value
11  [=, &x, &y = std::as_const(y)] {
12    std::cout << "Sum: " << x + y + z;
13  }();
14}

1Sum: 6

Using Attributes

Lambdas can specify attributes such as [[nodiscard]] after the capture group:

1int main() {
2  auto Lambda{[] [[nodiscard]] { return 5; }};
3
4  Lambda();
5}

1warning: ignoring return value of 'Lambda', declared with attribute 'nodiscard'

Attributes

Explore the fundamentals of attributes, including [[nodiscard]], [[likely]], and [[deprecated]]

If our lambda includes a parameter list, we place the attribute before it. Below, we use the [[deprecated]] attribute in a lambda that has both a parameter list and a return type:

1int main() {
2  auto Lambda{[] [[deprecated("Oh no!")]]
3      (int x, int y) -> int { return x + y; }
4  };
5
6  Lambda(1, 2);
7}

1warning: Lambda is deprecated: Oh no!

Summary

In this lesson, we've explored lambdas, demonstrating how they provide a concise way to write inline functions for specific tasks. The key topics we learned includes:

• Lambdas offer a concise syntax for creating functions that can be defined almost anywhere, including within other functions.
• A basic lambda expression consists of a set of square brackets for captures, followed by a code block where the lambda's functionality is implemented.
• Parameters can be added to a lambda by including them in parentheses between the capture brackets and the code block.
• The return type of a lambda can be automatically inferred by the compiler, or explicitly specified using the -> syntax followed by the type.
• Captures allow a lambda to access variables from its enclosing scope, either by value or by reference, with the ability to modify captured variables if the lambda is marked as mutable.
• Default captures can simplify code by automatically capturing all used variables either by value or by reference, as indicated by = or &, respectively.
• Lambdas can also specify attributes like [[nodiscard]] or [[deprecated]] to enforce certain behaviors or warnings at compile time.

Next Lesson

Standard Library Function Helpers

A comprehensive overview of function helpers in the standard library, including std::invocable, std::predicate and std::function.

ContinueView Course