Does the standard guarantee that the standard library std::hash<> specializations produce identical hashes for values that compare equal, even if they are of different types? For example, would the following two always produce the same value?

std::hash<std::int32_t>{}(1);
std::hash<std::int64_t>{}(1);

The context for my question is: I am using a hash class that allows for transparent lookup for isomorphic tuple types, for example, given an unordered_map like so:

std::unordered_map<std::tuple<int, string, double>, string>

I can do a lookup on it with a std::tuple<int, string&, double>. The implementation just uses std::hash on each element and combines the hashes together. In this case, if I am given a std::tuple<int64_t, string, double>, I'm wondering if I can assume the hash of this would produce the same output if each tuple element compares equal.

Does the standard guarantee that the standard library std::hash<> specializations produce identical hashes for values that compare equal, even if they are of different types? For example, would the following two always produce the same value?

std::hash<std::int32_t>{}(1);
std::hash<std::int64_t>{}(1);

The context for my question is: I am using a hash class that allows for transparent lookup for isomorphic tuple types, for example, given an unordered_map like so:

std::unordered_map<std::tuple<int, string, double>, string>

I can do a lookup on it with a std::tuple<int, string&, double>. The implementation just uses std::hash on each element and combines the hashes together. In this case, if I am given a std::tuple<int64_t, string, double>, I'm wondering if I can assume the hash of this would produce the same output if each tuple element compares equal.

• c++
• hash

• There is not such guarantee. – 3CxEZiVlQ Commented Apr 2 at 3:14
• 2 I would think any such guarantee would be extremely difficult for UDT. Just std::string and char* could theoretically have different hashes. I would actually not be surprised, however, if it does in fact end up producing identical hashes for int and long long int for the common value range. – SoronelHaetir Commented Apr 2 at 3:24
• 1 std::hash<std::int32_t> and std::hash<std::int64_t> are each unique unrelated types which can (must) implement their own hash function. So no you cannot make that assumption. D not misuse std::tuple like you are doing, make a struct type with 3 members (std::tuple is supposed to be used in (meta) template programming only not as a tool to safe some typing). Making such a struct will also allow you to write your own hash function specialization where you can build in the behavior you want. – Pepijn Kramer Commented Apr 2 at 3:30
• 2 some implementations of std::hash use the identity function for the hash so the value and the hash are the same thing. That would me all 32bit numbers in a 32 bit or 64 bit type will have the same hash. You can't rely on this though. – NathanOliver Commented Apr 2 at 3:40

1 Answer 1

From cppreference:

The actual hash functions are implementation-dependent and are not required to fulfill any other quality criteria except those specified above.

The criteria referenced by this quote are mostly technical (e.g. default constructible), plus the traditional hash requirement: if two values of the type Key compare equal, then std::hash<Key>{}() maps those input values to the same hash value. In particular, there is no requirement imposed for input values of different types.

In general, it would be difficult (impossible) to require equality of hashes for equal values of different types. For user-defined types, one difficulty is that there might have not been a definition of equality when the hash function was defined. (Should introducing such an operator== invalidate existing hashes? No.) However, you're not using user-defined types, so this is just background as to why there is no universal requirement.

For strings, there is a requirement that std::hash<std::string_view> produce the same hash as std::hash<std::string> when the view and string are equal. So this is good for your use-case. (But be aware that this does not hold for null-terminated strings; std::hash<char*> hashes based upon the pointer value, not the pointed-to data.) For the standard arithmetic types, such a requirement would be technically possible, but it has not been imposed. Fortunately, though, cppreference goes on to note

Notably, some implementations use trivial (identity) hash functions which map an integer to itself.

If this is the case for your implementation, your plan would work (for as long as this remains true for your implementation).

On the other hand, why not apply a static_cast<int> before hashing to be sure?