std::hash

template< class Key >
struct hash;

Die ungeordneten assoziativen Container std::unordered_set, std::unordered_multiset, std::unordered_map, std::unordered_multimap verwenden Spezialisierungen der Vorlage std::hash als Standard-Hashfunktion.

Gegeben ein Typ Key, ist jede Spezialisierung std::hash<Key> entweder aktiviert oder deaktiviert :

• Wenn std::hash<Key> nicht durch das Programm oder den Benutzer bereitgestellt wird, ist sie deaktiviert.
• Ansonsten ist std::hash<Key> aktiviert, wenn alle folgenden Bedingungen erfüllt sind:

• Alle folgenden Anforderungen sind erfüllt:

• Hash (mit Key als Argumenttyp des Funktionsaufrufs)
• DefaultConstructible
• CopyAssignable
• Swappable

• Gegeben die folgenden Werte:

• h, ein Objekt vom Typ std::hash<Key>.
• k1 und k2, Objekte vom Typ Key.

Alle folgenden Anforderungen sind erfüllt:

• Wenn k1 == k2 true ist, ist h(k1) == h(k2) auch true.
• Sofern std::hash<Key> keine programmdefinierte Spezialisierung ist, wird h(k1) niemals eine Ausnahme werfen.

• Ansonsten ist std::hash<Key> deaktiviert.

Deaktivierte Spezialisierungen erfüllen Hash nicht, erfüllen FunctionObject nicht, und die folgenden Werte sind alle false:

• 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

Mit anderen Worten, sie existieren, können aber nicht verwendet werden.

Memberfunktionen

Standardbibliothek-Spezialisierungen

Jeder Header, der das Template std::hash deklariert, stellt auch aktivierte Spezialisierungen von std::hash für die folgenden Typen bereit:

• alle cv-unqualifizierten arithmetic types
• alle cv-unqualifizierten enumeration types
• alle cv-unqualifizierten pointer types
• std::nullptr_t

Darüber hinaus bieten einige Header auch andere aktivierte std::hash Spezialisierungen für Bibliothekstypen an (siehe unten ).

Spezialisierungen für Bibliothekstypen

Hinweise

Die eigentlichen Hash-Funktionen sind implementierungsabhängig und müssen keine anderen Qualitätskriterien erfüllen als die oben genannten. Insbesondere verwenden einige Implementierungen triviale (Identitäts-) Hash-Funktionen, die eine Ganzzahl auf sich selbst abbilden. Mit anderen Worten, diese Hash-Funktionen sind für die Verwendung mit ungeordneten assoziativen Containern konzipiert, jedoch nicht als kryptographische Hash-Funktionen, zum Beispiel.

Hash-Funktionen sind nur dazu verpflichtet, für dieselbe Eingabe innerhalb einer einzelnen Programmdurchführung dasselbe Ergebnis zu liefern; dies ermöglicht gesalzene Hashes, die Kollisions-DoS-Angriffe verhindern.

Es gibt keine Spezialisierung für C-Strings. std :: hash < const char * > erzeugt einen Hash des Zeigerwerts (der Speicheradresse), es werden nicht die Inhalte des Zeichenarrays untersucht.

Zusätzliche Spezialisierungen für std::pair und die Standard-Containertypen, sowie Hilfsfunktionen zum Kombinieren von Hashes sind verfügbar in boost::hash .

Beispiel

#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; // seit C++20
};
// Vor C++20.
// bool operator==(const S& lhs, const S& rhs)
// {
//     return lhs.first_name == rhs.first_name && lhs.last_name == rhs.last_name;
// }
// Benutzerdefinierter Hash kann ein eigenständiges Funktionsobjekt sein.
struct MyHash
{
    std::size_t operator()(const S& s) const noexcept
    {
        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); // oder boost::hash_combine verwenden
    }
};
// Benutzerdefinierte Spezialisierung von std::hash kann im Namespace std injiziert werden.
template<>
struct std::hash<S>
{
    std::size_t operator()(const S& s) const noexcept
    {
        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); // oder boost::hash_combine verwenden
    }
};
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"};
    // Verwendung des eigenständigen Funktionsobjekts.
    std::cout << "hash(" << std::quoted(obj.first_name) << ", "
              << std::quoted(obj.last_name) << ") =\t"
              << MyHash{}(obj) << " (mit MyHash) oder\n\t\t\t\t"
              << std::hash<S>{}(obj) << " (mit injizierter Spezialisierung)\n";
    // Benutzerdefinierter Hash ermöglicht die Verwendung benutzerdefinierter Typen in ungeordneten Containern.
    // Das Beispiel verwendet die oben injizierte std::hash<S>-Spezialisierung,
    // um stattdessen MyHash zu verwenden, übergeben Sie es als zweites Template-Argument.
    std::unordered_set<S> names = {obj, {"Bender", "Rodriguez"}, {"Turanga", "Leela"}};
    for (auto const& s: names)
        std::cout << std::quoted(s.first_name) << ' '
                  << std::quoted(s.last_name) << '\n';
}

hash("Treffe den neuen Chef...") =  10656026664466977650
hash("Hubert", "Farnsworth") =  12922914235676820612 (mit MyHash) oder
                                12922914235676820612 (mit injizierter Spezialisierung)
"Bender" "Rodriguez"
"Turanga" "Leela"
"Hubert" "Farnsworth"

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.