Home | Projects | Notes > C++ Programming > Lambda Expressions

Lambda Expressions

Overview

• What is lambda expression?

  • Motivation

  • Review of function objects (functors)

  • Relation between lambdas and function objects

• Structure of a lambda expression

• Types of lambda expressions

  • Stateless lambda expression

  • Stateful lambda expression (capturing context)

• Lambdas and the STL

Motivation

• Prior to C++11

  • Function objects

  • Function pointers

  • We often write many short functions that control algorithms

  • These short functions would be encapsulated in small classes to produce function objects

  • Many times the classes and functions are far removed from where they are used leading to modification, maintenance, and testing issues

  • Compiler cannot effectively inline these functions for efficiency.

Example

• Function objects

  xxxxxxxxxx
  14
  1
  class Multiplier
  2
  {
  3
  private:
  4
      int num{};
  5
  public:
  6
      Multiplier(int n) : num{n}      {}
  7
      int operator()(int n) const     { return num * n; }
  8
  };
  9
  
  10
  std::vector<int> vec{1, 2, 3, 4};
  11
  Multiplier mult{10};
  12
  
  13
  std::transform(vec.begin(), vec.end(), vec.begin(), mult);
  14
  // vec now contains {10, 20, 30, 40}
  

• Generic function objects

  xxxxxxxxxx
  20
  1
  template <typename T>
  2
  struct Displayer
  3
  {
  4
      void operator() (const T &data) { std::cout << data << " "; }
  5
  };
  6
  
  7
  Displayer<int> d1;
  8
  Displayer<std::string> d2;
  9
  
  10
  d1(100);        // d.operator(100);
  11
                  // displays 100
  12
  d2("Jack");     // d.operator("Jack");
  13
                  // displays Jack
  14
  
  15
  std::vector<int> vec1{1, 2, 3, 4, 5};
  16
  std::vector<std::string> vec2{"Jack", "Sunny", "Yena"};
  17
  
  18
  std::for_each(vec1.begin(), vec1.end(), Displayer<int>());
  19
  std::for_each(vec1.begin(), vec1.end(), d1);
  20
  std::for_each(vec2.begin(), vec2.end(), d2);
  

• Using a lambda expression

  xxxxxxxxxx
  5
  1
  std::vector<int> vec1{1, 2, 3, 4, 5};
  2
  std::vector<std::string> vec2{"Jack", "Sunny", "Yena"};
  3
  
  4
  std::for_each(vec1.begin(), vec1.end(), [](int x){ std::cout << x << " "; });
  5
  std::for_each(vec2.begin(), vec2.end(), [](std::string s){ std::cout << s << " ";});
  

   

Structure of a Lambda Expression

• The structure of a lambda expression

  xxxxxxxxxx
  1
  1
  [] () -> return_type specifiers { }; 
  

  • [] - Capture list: Defines the start of the lambda (Defines the context in which the lambda executes)

  • () - Parameter list: Comma separated list of parameters

  • return_type - Return type can be omitted and the compiler will try to deduce it.

  • specifiers - Optional specifiers

  • {} - Body of your code

Example

• A simple lambda expression

  xxxxxxxxxx
  1
  1
  [] () { std::cout << "Hi"; };
  

  xxxxxxxxxx
  1
  1
  [] () { std::cout << "Hi"; } ();    // Displays Hi
  

• Passing parameters to lambda expressions

  xxxxxxxxxx
  1
  1
  [] (int x) { std::cout << x; };
  

  xxxxxxxxxx
  1
  1
  [] (int x, int y) { std::cout << x + y; };
  

• Assigning a lambda expression to a variable

  xxxxxxxxxx
  2
  1
  auto l = [] () { std::cout << "Hi"; };
  2
  l();        // Displays Hi
  

  xxxxxxxxxx
  3
  1
  auto l = [] (int x) { std::cout << x; };
  2
  l(10);      // Displays 10
  3
  l(100);     // Displays 100
  

• Returning a value from a lambda expression

  xxxxxxxxxx
  6
  1
  auto l = [] (int x, int y) -> int { return x + y; };
  2
  // Or
  3
  auto l = [] (int x, int y) { return x + y; };
  4
  
  5
  std::cout << l(2, 3);       // Displays 5
  6
  std::cout << l(10, 20);     // Displays 30
  

   

C++ Stateless Lambda Expressions

• Simple stateless lambda expressions

  xxxxxxxxxx
  3
  1
  [] () { std::cout << "Hi"; } ();        // Displays Hi
  2
  int x{10};
  3
  [] (int x) { std::cout << x; }(100);
  

  xxxxxxxxxx
  12
  1
  const int n{3};
  2
  int num[n]{10, 20, 30};
  3
  
  4
  auto sum = [] (int nums[], int n)
  5
  {
  6
      int sum{0};
  7
      for (int i = 0; i < n; i++)
  8
          sum += nums[i];
  9
      return sum;
  10
  };
  11
  
  12
  std:: cout << sum(nums, 3);     // Displays 60
  

• Using values and references as lambda parameters

  xxxxxxxxxx
  2
  1
  [] (int x) { std::cout << x; };
  2
  [] (int &x) { std::cout << x; };
  

  • int x - Value parameter

  • int &x) - Reference parameter

  xxxxxxxxxx
  13
  1
  int test_score1{88};
  2
  int test_score2{75};
  3
  
  4
  auto bonus = [] (int &score1, int &score2, int bonus_points)
  5
  {
  6
      score1 += bonus_points;
  7
      score2 += bonus_points;
  8
  };
  9
  
  10
  bonus(test_score1, test_score2, 5);
  11
  
  12
  std::cout << "test_score1: " << test_score1 << std::endl;   // Displays 93
  13
  std::cout << "text_score2: " << test_score2 << std::endl;   // Displays 80
  

• Using pointers as lambda parameters

  xxxxxxxxxx
  3
  1
  int x;
  2
  auto l = [] (int *x) { std::cout << *x; };
  3
  l(&x);  // '&': Referencing (address-of) operator
  

  xxxxxxxxxx
  13
  1
  int test_score1{88};
  2
  int test_score2{75};
  3
  
  4
  auto bonus = [] (int *score1, int *score2, int bonus_points)
  5
  {
  6
      *score1 += bonus_points;
  7
      *score2 += bonus_points;
  8
  };
  9
  
  10
  bonus(&test_score1, &test_score2, 5);
  11
  
  12
  std::cout << "test_score1: " << test_score1 << std::endl;   // Displays 93
  13
  std::cout << "text_score2: " << test_score2 << std::endl;   // Displays 80
  

• Using arrays and vectors as lambda reference parameters

  xxxxxxxxxx
  16
  1
  std::vector<int> test_scores{ 93, 88, 75, 68, 65 };
  2
  
  3
  auto bonus = [] (std::vector<int> &scores, int bonus_points)
  4
  {
  5
      for (int &score : scores)
  6
          score += bonus_points;
  7
  };
  8
  
  9
  bonus(test_scores, 5);
  10
  
  11
  std::cout << "test_scores: " << std::endl;
  12
  std::cout << text_scores[0] << std::endl;   // Displays 98
  13
  std::cout << text_scores[1] << std::endl;   // Displays 93
  14
  std::cout << text_scores[2] << std::endl;   // Displays 80
  15
  std::cout << text_scores[3] << std::endl;   // Displays 73
  16
  std::cout << text_scores[4] << std::endl;   // Displays 70
  

• Using auto as lambda parameter type specifiers

  xxxxxxxxxx
  7
  1
  int num1{10};
  2
  float num2 {20.5};
  3
  
  4
  auto l = [] (auto x) { std::cout << x; };
  5
  
  6
  l(num1);
  7
  l(num2);
  

  xxxxxxxxxx
  11
  1
  std::vector<int> test_scores1 {93, 88, 75, 68, 65 };
  2
  std::vector<float> test_scores2 {88.5, 85.5, 75.5, 68.5, 65.5};
  3
  
  4
  auto bonus = [] (auto &scores, int bonus_points)
  5
  {
  6
      for (auto &score : scores)
  7
          score += bonus_points;
  8
  };
  9
  
  10
  bonus(test_scores1, 5);     // Valid
  11
  bonus(test_scores2, 5);     // Valid
  

• Using lambda expressions as function parameters

  xxxxxxxxxx
  13
  1
  #include <functional>       // For std::function
  2
  
  3
  void foo(std::function<void(int)> l) { l(10); }     // C++14
  4
  //                     ---- ---
  5
  //              return-type parameter-type
  6
  
  7
  // or
  8
  
  9
  void foo(void (*)(int)) { l(10); }                  // C++14
  10
  
  11
  // or
  12
  
  13
  void foo(auto l) { l(10); }                         // C++20
  

• Returning lambda expressions from functions

  xxxxxxxxxx
  11
  1
  #include <functional>       // For std::function
  2
  
  3
  std::function<void(int)> foo() { return [] (int x) { std::cout << x; }; }
  4
  
  5
  // or
  6
  
  7
  void (*foo())(int) { return [] (int x) { std::cout << x; }; }
  8
  
  9
  // or
  10
  
  11
  auto foo() { return [] (int x) { std::cout << x; }; }
  

  All 3 versions are used the same way.

  xxxxxxxxxx
  2
  1
  auto l = foo();
  2
  l(10);      // Displays 10
  

• Using lambda expressions as function parameters

  xxxxxxxxxx
  6
  1
  foo([] (int x) { std::cout << x; });
  2
  
  3
  // or
  4
  
  5
  auto l = [] (int x) { std::cout << x; };
  6
  foo(l);
  

• Using lambda expressions as predicates

  xxxxxxxxxx
  18
  1
  void print_if(std::vector<int> nums, bool (*predicate)(int))
  2
  {
  3
      for (int i : nums)
  4
      {
  5
          if (predicate(i))
  6
              std::cout << i;
  7
      }
  8
  }
  9
  
  10
  int main()
  11
  {
  12
      std::vector<int> nums{1, 2, 3};
  13
      
  14
      print_if(nums, [] (auto x) { return x % 2 == 0; }); // Displays evens
  15
      print_if(nums, [] (auto x) { return x % 2 != 0; }); // Displays odds
  16
      
  17
      return 0;
  18
  }
  

C++ Stateful Lambda Expressions

• The structure of a stateful lambda expression

  xxxxxxxxxx
  1
  1
  [captured_variables] () -> return_type specifiers { };
  

  captured_variables - Non-empty capture list: Defines what information/variables should be captured.

• Compilation of stateless lambda expressions 1

  Lambda definition

  xxxxxxxxxx
  1
  1
  auto l = [] (int x) { std::cout << x; };
  

  Compiler-generated closure

  xxxxxxxxxx
  7
  1
  class CompilerGeneratedName
  2
  {
  3
  public:
  4
      CompilerGeneratedName();
  5
      
  6
      void operator() (int x) { std::cout << x; }
  7
  };
  

• Compilation of stateless lambda expressions 2

  Lambda definition

  xxxxxxxxxx
  2
  1
  int y {10};
  2
  auto l = [y] (int x) { std::cout << x + y; };
  

  Compiler-generated closure

  xxxxxxxxxx
  9
  1
  class CompilerGeneratedName
  2
  {
  3
  private:
  4
      int y;
  5
  public:
  6
      CompilerGeneratedName(int y) : y{y} { };
  7
      
  8
      void operator() (int x) const { std::cout << x + y; }
  9
  };
  

• Capture by value

  xxxxxxxxxx
  2
  1
  int x{100};
  2
  [x] () { std::cout << x; }();       // Displays 100
  

• Using mutable to modify variables captured by value

  xxxxxxxxxx
  9
  1
  int x{100};
  2
  
  3
  [x] () mutable
  4
  {
  5
      x += 100;
  6
      std::cout << x;     // Displays 200
  7
  } ();
  8
  
  9
  std::cout << x;         // Displays 100
  

• Capture by reference

  xxxxxxxxxx
  4
  1
  int x{100};
  2
  
  3
  [&x] () { x += 100; }();
  4
  std::cout << x;         // Displays 200
  

• Capture by value and reference

  xxxxxxxxxx
  4
  1
  [x, y]      // Capture both x and y by value
  2
  [x, &y]     // Capture x by value and y by reference
  3
  [&x, y]     // Capture x by reference and y by value
  4
  [&x, &y]    // Capture both x and y by reference
  

• Default captures

  xxxxxxxxxx
  3
  1
  [=]         // Default capture by value
  2
  [&]         // Default capture by reference
  3
  [this]      // Default capture this object by reference
  

• Using default and explicit captures

  xxxxxxxxxx
  3
  1
  [=, &x]     // Default capture by value but capture x by reference
  2
  [&, y]      // Default capture by reference but capture y by value
  3
  [this, z]   // Default capture this by but capture z by value