How to std::hash an unordered std::pair

Question

I want to be able to use a std::pair as a key in an unordered_container. I know that I could do this the following way:

template<typename T>
void
hash_combine(std::size_t &seed, T const &key) {
  std::hash<T> hasher;
  seed ^= hasher(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}

namespace std {
  template<typename T1, typename T2>
  struct hash<std::pair<T1, T2>> {
    std::size_t operator()(std::pair<T1, T2> const &p) const {
      std::size_t seed(0);
      ::hash_combine(seed, p.first);
      ::hash_combine(seed, p.second);
      return seed;
    }
  };
}

However, I want the hashing to ignore the order of the elements in the std::pair (i.e., to return the same seed for std::pair<A, B> and std::pair<B, A>).

One way I thought to achieve this is to apply some kind of ordering when creating my std::pair<A, B> (i.e., some kind of custom std::make_pair). But this is too restrictive since objects A, B might not have an order.

Q:

Is there a standard way to hash a std::pair, such that the order of elements is ignored and the same seed is returned either for std::pair<A, B> and std::pair<B, A>?

You could use `^` to combine the hashes. See also https://stackoverflow.com/questions/5889238/why-is-xor-the-default-way-to-combine-hashes EDIT: Second thought: This may not be good for `std::pair` since all pairs with equal values will have hash `0`. — Wintermute, Feb 06 '15 at 14:30
@Wintermute Thanks for the reply, I've seen that thread, but as you've already mentioned this doesn't suit my needs due to the deterioration you've also mentioned ;). — 101010, Feb 06 '15 at 14:37
`to return the same seed for std::pair and std::pair` Why, if you don't mind me asking? What problem are you trying to solve where this (rather unusual) property would be of help? — Igor Tandetnik, Feb 06 '15 at 14:37
@Wintermute That can be solved by a specialization taking only a single template argument, which does something different from the specialization taking two template arguments. And maybe a `static_assert` to make sure the user of the two-argument template doesn't provide the same types for both template arguments. Not perfect, but better than nothing I guess. — Some programmer dude, Feb 06 '15 at 14:37
[guava](https://code.google.com/p/guava-libraries/source/browse/guava/src/com/google/common/hash/Hashing.java#379) does it by bytewise addition of the individual hashes, so that's probably not a completely insane solution. — Wintermute, Feb 06 '15 at 14:38
So how exactly would a "collision tracker" make use of this property? Suppose you managed to implement the hash the way you want - can you show an example of how you would use it? — Igor Tandetnik, Feb 06 '15 at 14:40
@HowardHinnant This is what I did, since the sum is commutative the order of the pair's values doesn't matter. — ABu, Jul 30 '19 at 19:25

Angew is no longer proud of SO · Accepted Answer · 2015-02-06T15:19:14.277

16

Don't order the pairs, order the hashes:

namespace std {
  template<typename T1, typename T2>
  struct hash<std::pair<T1, T2>> {
    std::size_t operator()(std::pair<T1, T2> const &p) const {
      std::size_t seed1(0);
      ::hash_combine(seed1, p.first);
      ::hash_combine(seed1, p.second);

      std::size_t seed2(0);
      ::hash_combine(seed2, p.second);
      ::hash_combine(seed2, p.first);

      return std::min(seed1, seed2);
    }
  };
}

[Live example]

edited Feb 06 '15 at 15:19

answered Feb 06 '15 at 14:42

Angew is no longer proud of SO

167,307
17
350
455

4

You could also order them via type_info::before, which eliminates half the hash calculation (and possibly even the "if" check, depending on how good the optimizer is). – Nevin Feb 06 '15 at 15:28
@Nevin could you provide a live example please? – 101010 Feb 06 '15 at 22:07
This solution does not scale from pairs to tuples of arbitrary length. – Jakub Klinkovský Dec 12 '17 at 15:55

How to std::hash an unordered std::pair

Q:

1 Answers1

Linked