Writing Custom Hash Functions

To write a custom hash function for your own data type, you need to specialize the std::hash template for your type. Here's a step-by-step guide:

Step 1: Create your custom data type, for example, a Person struct:

1#include <string>
2
3struct Person {
4  std::string name;
5  int age;
6};

Step 2: Specialize the std::hash template for your data type:

1#include <utility>
2#include <string>
3
4namespace std {
5template <>
6struct hash<Person> {
7  size_t operator()(const Person& person) const {
8    // Combine the hash values of name and age
9    size_t nameHash =
10      std::hash<std::string>{}(person.name);
11    size_t ageHash =
12      std::hash<int>{}(person.age);
13    return nameHash ^ (ageHash << 1);  
14  }
15};
16}

In the operator() function, you define how to calculate the hash value for your data type. In this example, we combine the hash values of the name and age members using the XOR operator (^) and left shift (<<).

Step 3: Ensure that your data type has a proper equality comparison operator (operator==):

1bool operator==(const Person& lhs,
2  const Person& rhs) {
3  return lhs.name == rhs.name
4    && lhs.age == rhs.age;
5}

This is necessary because hash tables use equality comparison to resolve collisions.

Now you can use your custom data type with hash-based containers like std::unordered_set or std::unordered_map:

1#include <utility>
2#include <string>
3#include <iostream>
4#include <unordered_set>
5
Person Struct|Show
6struct Person {/*...*/}
11
Overload of == Operator|Show
12bool operator==(Person, Person) {/*...*/}
18
Specialization of std::hash|Show
19namespace std {/*...*/}
33
34int main() {
35  std::unordered_set<Person> people;
36
37  people.insert({"John", 30});
38  people.insert({"Alice", 25});
39
40  for (const auto& person : people) {
41    std::cout << person.name << " - "
42      << person.age << '\n';
43  }
44}

1John - 30
2Alice - 25

Remember, a good hash function should distribute the hash values uniformly across the range of possible values to minimize collisions and maintain the efficiency of hash-based containers.