Generic Hash Function for Tuples in Unordered Collections

The std::unordered_map and std::unordered_set containers provide efficient lookup and insertion of elements based on their hashed values. However, using tuples as keys in these collections without defining a custom hash function can lead to unexpected behavior.

To rectify this, one approach is to manually define a hash function for the specific tuple type, such as:

template
struct std::hash<:tuple int>> {
  size_t operator()(std::tuple const& tuple) const { ... }
};

While this approach works, it can be tedious to define hash functions for every tuple type used. To automate this, a generic hash function can be implemented as follows:

#include 

namespace std {
  namespace {

    // Code derived from Boost
    template
    inline void hash_combine(std::size_t& seed, T const& v) { ... }

    // Recursive template code from Matthieu M.
    template::value - 1>
    struct HashValueImpl { ... };

  }

  template
  struct hash<:tuple>> {
    size_t operator()(std::tuple const& tuple) const { ... }
  };
}

This function leverages argument-dependent name lookup (ADL) to allow the compiler to automatically select the correct hash implementation based on the tuple type.

Standard Conformant Solution

It is worth noting that defining non-standard functions in the std namespace is undefined behavior. For a standards-compliant solution, a custom namespace can be created and used to define the hash function:

namespace my_hash {

  // Forward non-tuple types to the std::hash
  template
  struct hash { ... };

  // Provide the optimized hash for tuples
  template
  struct hash<:tuple>> { ... };

}

When using this solution, the unordered collection must explicitly reference the custom hash implementation as follows:

unordered_set,
  std::hash<:tuple int>>,
  std::equal_to<:tuple int>>
> test;