Using Lambdas as Comparators

Yes, lambdas are often used as comparators for STL containers and algorithms. This is because lambdas provide a concise way to define a comparison operation right where it's needed.

For example, let's say you have a std::vector of Player objects, each of which has a score member. You can sort this vector based on the scores using std::sort and a lambda comparator:

1#include <iostream>
2#include <vector>
3#include <algorithm>
4
5struct Player {
6  std::string name;
7  int score;
8};
9
10int main() {
11  std::vector<Player> players {
12    {"Alice", 30},
13    {"Bob", 50},
14    {"Charlie", 40}
15  };
16
17  std::sort(players.begin(), players.end(),
18    [](const Player& a, const Player& b) {
19      return a.score < b.score;
20    });
21
22  for (const auto& player : players) {
23    std::cout << player.name << ": "
24      << player.score << '\n';
25  }
26}

1Alice: 30
2Charlie: 40
3Bob: 50

Here, std::sort is called with three arguments: the start of the range to sort, the end of the range, and a comparator.

The comparator is a lambda that takes two Player objects and returns true if the first player's score is less than the second player's score. This lambda will be called by std::sort to determine the order of the elements.

This same technique can be used with other algorithms and containers in the STL. For example, you could use a lambda comparator with std::set or std::map to specify a custom ordering for the elements.

Using lambdas as comparators is often preferable to defining a separate named comparator function, as it keeps the comparison logic right where it's used and avoids cluttering the global namespace.