Requiring Equality Operator

You can create a concept that requires a class to have a properly defined equality operator (operator==). Here's an example:

1#include <concepts>
2
3template <typename T>
4concept EqualityComparable =
5  requires(T a, T b) {
6    { a == b } -> std::convertible_to<bool>;
7    { a != b } -> std::convertible_to<bool>;
8};
9
10class Player {
11 public:
12  int Score;
13
14  bool operator==(const Player& other) const {
15    return Score == other.Score; }
16
17  bool operator!=(const Player& other) const {
18    return !(*this == other); }
19};
20
21// Passes
22static_assert(EqualityComparable<Player>);

The EqualityComparable concept checks if a type T has the equality operators == and != defined.

The requirements { a == b } -> std::convertible_to<bool> and { a != b } -> std::convertible_to<bool> specify that the expressions a == b and a != b should be convertible to bool, where a and b are instances of type T.

In the Player class, we define operator== to compare the Score members, and operator!= to negate the result of operator==.

The static_assert at the end verifies that Player satisfies the EqualityComparable concept.

Note that the standard library already provides the std::equality_comparable concept, which you can use directly instead of defining your own:

1static_assert(std::equality_comparable<Player>);