std:: hash

Die aktivierten Spezialisierungen der hash -Vorlage definieren ein Funktionsobjekt, das eine Hash-Funktion implementiert.

Für einen Typ Key ist jede Spezialisierung std::hash<Key> entweder aktiviert oder deaktiviert :

• Wenn std::hash<Key> nicht vom Programm oder Benutzer bereitgestellt wird, ist es deaktiviert.
• Andernfalls ist std::hash<Key> aktiviert, wenn alle folgenden Bedingungen erfüllt sind:

• Alle folgenden Anforderungen sind erfüllt:

• Hash (mit Key als Funktionsaufrufargumenttyp)
• DefaultConstructible
• CopyAssignable
• Swappable

• Gegeben sind folgende 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 den Wert true hat, dann hat auch h ( k1 ) == h ( k2 ) den Wert true .
• Sofern es sich bei std::hash<Key> nicht um eine programmdefinierte Spezialisierung handelt, wird h ( k1 ) niemals eine Exception werfen.

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

Deaktivierte Spezialisierungen erfüllen nicht Hash , erfüllen nicht FunctionObject , und folgende 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.