The enabled specializations of thehash template define a function object that implements ahash function.

Given a typeKey, each specializationstd::hash<Key> is eitherenabled ordisabled :

• Ifstd::hash<Key> is not provided by the program or the user, it is disabled.
• Otherwise,std::hash<Key> is enabled if all following conditions are satisfied:

• All following requirements are satisfied:

• Hash (withKey as the function call argument type)
• DefaultConstructible
• CopyAssignable
• Swappable

• Given the following values:

• h, an object of typestd::hash<Key>.
• k1 andk2, objects of typeKey.

All following requirements are satisfied:

• Ifk1== k2 istrue,h(k1)== h(k2) is alsotrue.
• Unlessstd::hash<Key> is aprogram-defined specialization,h(k1) will never throw an exception.

• Otherwise,std::hash<Key> is disabled.

Disabled specializations do not satisfyHash, do not satisfyFunctionObject, and following values are allfalse:

• std::is_default_constructible<std::hash<Key>>::value
• std::is_copy_constructible<std::hash<Key>>::value
• std::is_move_constructible<std::hash<Key>>::value
• std::is_copy_assignable<std::hash<Key>>::value
• std::is_move_assignable<std::hash<Key>>::value

In other words, they exist, but cannot be used.

[edit]Member functions

[edit]Standard library specializations

Each header that declares the templatestd::hash also provides enabled specializations ofstd::hash for the following types:

• all cv-unqualifiedarithmetic types
• all cv-unqualifiedenumeration types
• all cv-unqualifiedpointer types
• std::nullptr_t

On top of that, some headers also provide other enabledstd::hash specializations for library types (seebelow).

[edit]Specializations for library types

[edit]Notes

The actual hash functions are implementation-dependent and are not required to fulfill any other quality criteria except those specified above. Notably, some implementations use trivial (identity) hash functions which map an integer to itself. In other words, these hash functions are designed to work with unordered associative containers, but not as cryptographic hashes, for example.

Hash functions are only required to produce the same result for the same input within a single execution of a program; this allows salted hashes that prevent collision denial-of-service attacks.

There is no specialization for C strings.std::hash<constchar*> produces a hash of the value of the pointer (the memory address), it does not examine the contents of any character array.

Additional specializations forstd::pair and the standard container types, as well as utility functions to compose hashes are available inboost::hash.

[edit]Example

#include <cstddef>#include <functional>#include <iomanip>#include <iostream>#include <string>#include <unordered_set> struct S{std::string first_name;std::string last_name;bool operator==(const S&)const=default;// since C++20}; // Before C++20.// bool operator==(const S& lhs, const S& rhs)// {//     return lhs.first_name == rhs.first_name && lhs.last_name == rhs.last_name;// } // Custom hash can be a standalone function object.struct MyHash{std::size_t operator()(const S& s)constnoexcept{std::size_t h1= std::hash<std::string>{}(s.first_name);std::size_t h2= std::hash<std::string>{}(s.last_name);return h1^(h2<<1);// or use boost::hash_combine}}; // Custom specialization of std::hash can be injected in namespace std.template<>struct std::hash<S>{std::size_t operator()(const S& s)constnoexcept{std::size_t h1= std::hash<std::string>{}(s.first_name);std::size_t h2= std::hash<std::string>{}(s.last_name);return h1^(h2<<1);// or use boost::hash_combine}}; int main(){std::string str="Meet the new boss...";std::size_t str_hash= std::hash<std::string>{}(str);std::cout<<"hash("<<std::quoted(str)<<") =\t"<< str_hash<<'\n';     S obj={"Hubert","Farnsworth"};// Using the standalone function object.std::cout<<"hash("<<std::quoted(obj.first_name)<<", "<<std::quoted(obj.last_name)<<") =\t"<< MyHash{}(obj)<<" (using MyHash) or\n\t\t\t\t"<< std::hash<S>{}(obj)<<" (using injected specialization)\n"; // Custom hash makes it possible to use custom types in unordered containers.// The example will use the injected std::hash<S> specialization above,// to use MyHash instead, pass it as a second template argument.std::unordered_set<S> names={obj,{"Bender","Rodriguez"},{"Turanga","Leela"}};for(autoconst& s: names)std::cout<<std::quoted(s.first_name)<<' '<<std::quoted(s.last_name)<<'\n';}

hash("Meet the new boss...") =  10656026664466977650hash("Hubert", "Farnsworth") =  12922914235676820612 (using MyHash) or                                12922914235676820612 (using injected specialization)"Bender" "Rodriguez""Turanga" "Leela""Hubert" "Farnsworth"

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文