Using Lambda Expressions as Projection Functions in C++

Lambda expressions are a powerful feature in C++ that allow you to define anonymous functions directly in your code.

They can be effectively used as projection functions due to their concise syntax and ability to capture variables from their enclosing scope.

Basic Example:

Consider sorting a collection of Player objects by their Level attribute using a lambda expression as the projection function:

1#include <vector>
2#include <iostream>
3#include <algorithm>
4
5struct Player {
6  std::string Name;
7  int Level;
8};
9
10int main() {
11  std::vector<Player> Party {
12    {"Legolas", 49},
13    {"Gimli", 47},
14    {"Gandalf", 53}
15  };
16
17  std::ranges::sort(Party, {},
18    [](const Player& P) { return P.Level; });
19
20  for (const auto& P : Party) {
21    std::cout << "[" << P.Level << "] "
22      << P.Name << "\n";
23  }
24}

1[47] Gimli
2[49] Legolas
3[53] Gandalf

In this example, the lambda expression [](const Player& P) { return P.Level; } is used as the projection function to extract the Level attribute from each Player object.

Capturing Variables:

Lambdas can also capture variables from their enclosing scope. This is useful when the projection needs additional context:

1#include <vector>
2#include <iostream>
3#include <algorithm>
4
5struct Player {
6  std::string Name;
7  int Level;
8};
9
10int main() {
11  std::vector<Player> Party {
12    {"Legolas", 49},
13    {"Gimli", 47},
14    {"Gandalf", 53}
15  };
16
17  int levelCap = 50;
18  std::ranges::sort(Party, {},
19    [levelCap](const Player& P) {
20      return (P.Level < levelCap)
21        ? P.Level
22        : levelCap;
23    }
24  );
25
26  for (const auto& P : Party) {
27    std::cout << "[" << P.Level << "] "
28      << P.Name << "\n";
29  }
30}

1[47] Gimli
2[49] Legolas
3[50] Gandalf

In this example, the lambda captures the levelCap variable and uses it within the projection function.

Key Points:

• Syntax: Lambdas provide a concise way to define projection functions inline.
• Captures: Use captures to include external variables within the lambda's scope.
• Flexibility: Lambdas can be used for simple attribute access or more complex transformations.

Using lambda expressions as projection functions enhances the flexibility and readability of your code, allowing you to define custom projections directly where they are needed.