Using std::unordered_set with Smart Pointers

To store smart pointers like std::unique_ptr in a std::unordered_set, you need to provide a custom hash function and a custom equality comparator that operate on the underlying raw pointers.

Here's an example of using std::unique_ptr with std::unordered_set:

1#include <iostream>
2#include <memory>
3#include <unordered_set>
4
5struct Player {
6  std::string Name;
7  int Score;
8
9  Player(const std::string& Name, int Score)
10    : Name{Name}, Score{Score} {}
11};
12
13struct PlayerHash {
14  size_t operator()(
15    const std::unique_ptr<Player>& P) const {
16    return std::hash<Player*>{}(P.get());  
17  }
18};
19
20struct PlayerEqual {
21  bool operator()(
22    const std::unique_ptr<Player>& A,
23    const std::unique_ptr<Player>& B
24  ) const {
25    return A.get() == B.get();  
26  }
27};
28
29int main() {
30  std::unordered_set<std::unique_ptr<Player>,
31    PlayerHash, PlayerEqual> Players;  
32
33  Players.emplace(
34    std::make_unique<Player>("Alice", 100));
35  Players.emplace(
36    std::make_unique<Player>("Bob", 200));
37
38  for (const auto& Player : Players) {
39    std::cout << Player->Name << ": "
40      << Player->Score << "\n";
41  }
42}

1Alice: 100
2Bob: 200

In this example:

• We define a Player struct with Name and Score members
• We create a PlayerHash struct that overloads operator() to hash the raw pointer stored inside the std::unique_ptr
• We create a PlayerEqual struct that overloads operator() to compare the raw pointers stored inside the std::unique_ptrs for equality
• We specify std::unique_ptr<Player> as the key type and provide PlayerHash and PlayerEqual as the hash function and equality comparator when creating the std::unordered_set
• We use std::make_unique to create std::unique_ptr<Player> objects and insert them into the set using emplace()

By providing custom hash and equality functions that operate on the raw pointers, we enable std::unordered_set to store and compare std::unique_ptr<Player> objects correctly.

Note that using smart pointers in an unordered set compares the pointers themselves, not the objects they point to. If you want to compare the pointed-to objects, you'll need to dereference the smart pointers in your custom comparator and hash function.