std::hash

template< class Key >
struct hash;

Los contenedores asociativos no ordenados std::unordered_set, std::unordered_multiset, std::unordered_map, std::unordered_multimap usan especializaciones de la plantilla std::hash como función hash predeterminada.

Dado un tipo Key, cada especialización std::hash<Key> está habilitada o deshabilitada :

• Si std::hash<Key> no es proporcionada por el programa o el usuario, está deshabilitada.
• En caso contrario, std::hash<Key> está habilitada si se cumplen todas las condiciones siguientes:

• Todos los requisitos siguientes se cumplen:

• Hash (con Key como tipo de argumento de llamada a función)
• DefaultConstructible
• CopyAssignable
• Swappable

• Dados los siguientes valores:

• h, un objeto de tipo std::hash<Key>.
• k1 y k2, objetos de tipo Key.

Todos los requisitos siguientes se cumplen:

• Si k1 == k2 es true, h(k1) == h(k2) también es true.
• A menos que std::hash<Key> sea una especialización definida por el programa, h(k1) nunca lanzará una excepción.

• En caso contrario, std::hash<Key> está deshabilitada.

Las especializaciones deshabilitadas no cumplen Hash, no cumplen FunctionObject, y los siguientes valores son todos 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

En otras palabras, existen, pero no pueden ser utilizadas.

Funciones miembro

Especializaciones de la biblioteca estándar

Cada encabezado que declara la plantilla std::hash también proporciona especializaciones habilitadas de std::hash para los siguientes tipos:

• todos los tipos aritméticos sin calificadores cv
• todos los tipos de enumeración sin calificadores cv
• todos los tipos de puntero sin calificadores cv
• std::nullptr_t

Además de eso, algunos encabezados también proporcionan otras especializaciones habilitadas std::hash para tipos de biblioteca (ver abajo ).

Especializaciones para tipos de biblioteca

Notas

Las funciones hash reales dependen de la implementación y no están obligadas a cumplir ningún otro criterio de calidad excepto los especificados anteriormente. Cabe destacar que algunas implementaciones utilizan funciones hash triviales (identidad) que mapean un entero a sí mismo. En otras palabras, estas funciones hash están diseñadas para funcionar con contenedores asociativos no ordenados, pero no como hashes criptográficos, por ejemplo.

Las funciones hash solo están obligadas a producir el mismo resultado para la misma entrada dentro de una única ejecución de un programa; esto permite hashes con sal que previenen ataques de denegación de servicio por colisión.

No existe una especialización para cadenas C. std :: hash < const char * > produce un hash del valor del puntero (la dirección de memoria), no examina el contenido de ningún arreglo de caracteres.

Especializaciones adicionales para std::pair y los tipos de contenedores estándar, así como funciones de utilidad para componer hashes están disponibles en boost::hash .

Ejemplo

#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; // desde C++20
};
// Antes de C++20.
// bool operator==(const S& lhs, const S& rhs)
// {
//     return lhs.first_name == rhs.first_name && lhs.last_name == rhs.last_name;
// }
// El hash personalizado puede ser un objeto función independiente.
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); // o usar boost::hash_combine
    }
};
// La especialización personalizada de std::hash puede inyectarse en el espacio de nombres std.
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); // o usar 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"};
    // Usando el objeto función independiente.
    std::cout << "hash(" << std::quoted(obj.first_name) << ", "
              << std::quoted(obj.last_name) << ") =\t"
              << MyHash{}(obj) << " (usando MyHash) o\n\t\t\t\t"
              << std::hash<S>{}(obj) << " (usando especialización inyectada)\n";
    // El hash personalizado permite usar tipos personalizados en contenedores desordenados.
    // El ejemplo usará la especialización inyectada std::hash<S> anterior,
    // para usar MyHash en su lugar, páselo como segundo argumento de plantilla.
    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("Conoce al nuevo jefe...") =  10656026664466977650
hash("Hubert", "Farnsworth") =  12922914235676820612 (usando MyHash) o
                                12922914235676820612 (usando especialización inyectada)
"Bender" "Rodriguez"
"Turanga" "Leela"
"Hubert" "Farnsworth"

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.