Requirements for Custom Key Types in std::unordered_map

To use a custom type as the key in std::unordered_map, the type must meet the following requirements:

1. Hash Function: The custom type must have a hash function specialization for std::hash. This function calculates the hash value for objects of the custom type. If not provided, you need to supply a custom hash function as a template argument to std::unordered_map.
2. Equality Comparison: The custom type must have an equality comparison operator (operator==) defined. This operator is used to determine if two keys are equal, especially in case of hash collisions. If not provided, you need to supply a custom equality comparison function as a template argument to std::unordered_map.

Here's an example of a custom type meeting these requirements:

1#include <iostream>
2#include <string>
3#include <unordered_map>
4
5struct Player {
6  std::string name;
7  int score;
8
9  bool operator==(const Player& other) const {  
10    return name == other.name
11      && score == other.score;
12  }
13};
14
15namespace std {
16template <>
17struct hash<Player> {  
18  size_t operator()(const Player& player) const {
19    size_t nameHash =
20      std::hash<std::string>{}(player.name);
21    size_t scoreHash =
22      std::hash<int>{}(player.score);
23    return nameHash ^ (scoreHash << 1);
24  }
25};
26}
27
28int main() {
29  std::unordered_map<Player, int> playerMap;
30
31  playerMap[Player{"Alice", 100}] = 1;
32  playerMap[Player{"Bob", 200}] = 2;
33
34  for (const auto& [player, id] : playerMap) {
35    std::cout << "Player: " << player.name
36      << ", Score: " << player.score
37      << ", ID: " << id << '\n';
38  }
39}

1Player: Alice, Score: 100, ID: 1
2Player: Bob, Score: 200, ID: 2

In this example, the Player type has an operator== for equality comparison and a specialization of std::hash to calculate the hash value based on the name and score members.

If the custom type doesn't provide these functions, you can supply them as additional template arguments to std::unordered_map:

1#include <iostream>
2#include <string>
3#include <unordered_map>
4
5struct Player {
6  std::string name;
7  int score;
8};
9
10struct PlayerHash {
11  size_t operator()(const Player& player) const {
12    // Custom hash function implementation
13  }
14};
15
16struct PlayerEqual {
17  bool operator()(
18    const Player& lhs, const Player& rhs) const {
19    // Custom equality comparison implementation
20  }
21};
22
23std::unordered_map<
24  Player, int, PlayerHash, PlayerEqual> playerMap;

By meeting these requirements, you can use custom types as keys in std::unordered_map, enabling efficient lookup and insertion operations based on the custom type's hash value and equality comparison.