std::hash

 

C++

Lenguaje

Cabeceras

Conceptos

Biblioteca de utilidades

Biblioteca de cadenas

Biblioteca de contenedores

Biblioteca de algoritmos

Biblioteca de iteradores

Biblioteca numérica

Biblioteca de entrada/salida

Biblioteca de localización

Biblioteca de expresiones regulares (C++11)

Biblioteca de operaciones atómicas (C++11)

Biblioteca de hilos/subprocesos (C++11)

 

Utilidades de la biblioteca

Escriba apoyo (basic types, RTTI, type traits)

Gestión de memoria dinámica

Gestión de errores

Programa de servicios públicos

Funciones variadic

Fecha y hora

Objetos Function

initializer_list (C++11)

bitset

hash (C++11)

Operadores relacionales Original: Relational operators The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=

Pares y tuplas Original: Pairs and tuples The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

Cambiar, hacia adelante y mover Original: Swap, forward and move The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

swap

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

declval (C++11)

 

std::hash

hash::hash

hash::operator()

 

Definido en la cabecera <functional>
template< class Key > struct hash; // not defined		(desde C++11)

La plantilla de hachís define un objeto de función que implementa un función hash. Las instancias de este objeto de definir una función operator() que:

Original:

The hash template defines a function object that implements a función hash. Instances of this function object define an operator() that:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

1. Acepta un solo parámetro de tipo Key .

Original:

1. Accepts a single parameter of type Key.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

2. Devuelve un valor de tipo size_t que representa el valor hash del parámetro .

Original:

2. Returns a value of type size_t that represents the hash value of the parameter.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

3. No producir excepciones cuando se llama .

Original:

3. Does not throw exceptions when called.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

4. Para dos parámetros k1 y k2 que son iguales, std::hash<Key>()(k1) == std::hash<Key>()(k2) .

Original:

4. For two parameters k1 and k2 that are equal, std::hash<Key>()(k1) == std::hash<Key>()(k2).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

5. Para dos parámetros diferentes k1 y k2 que no son iguales, la probabilidad de que std::hash<Key>()(k1) == std::hash<Key>()(k2) debe ser muy pequeña, acercándose 1.0/std::numeric_limits<size_t>::max() .

Original:

5. For two different parameters k1 and k2 that are not equal, the probability that std::hash<Key>()(k1) == std::hash<Key>()(k2) should be very small, approaching 1.0/std::numeric_limits<size_t>::max().

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

La plantilla de hash es tanto CopyConstructible y Destructible .

Original:

The hash template is both CopyConstructible and Destructible.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

La desordenada contenedores asociativos std::unordered_set, std::unordered_multiset, std::unordered_map, std::unordered_multimap utilizar especializaciones de la plantilla std::hash como la función hash por defecto .

Original:

The unordered associative containers std::unordered_set, std::unordered_multiset, std::unordered_map, std::unordered_multimap use specializations of the template std::hash as the default hash function.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Tipos de miembros

argument_type	Key
result_type	std::size_t

Las funciones miembro

(constructor)	construye un objeto de función hash Original: constructs a hash function object The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (función miembro público)
operator()	calcular el hash del argumento Original: calculate the hash of the argument The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (función miembro público)

Especializaciones estándar para los tipos básicos

Definido en la cabecera <functional>
template<> struct hash<bool>; template<> struct hash<char>; template<> struct hash<signed char>; template<> struct hash<unsigned char>; template<> struct hash<char16_t>; template<> struct hash<char32_t>; template<> struct hash<wchar_t>; template<> struct hash<short>; template<> struct hash<unsigned short>; template<> struct hash<int>; template<> struct hash<unsigned int>; template<> struct hash<long>; template<> struct hash<long long>; template<> struct hash<unsigned long>; template<> struct hash<unsigned long long>; template<> struct hash<float>; template<> struct hash<double>; template<> struct hash<long double>; template< class T > struct hash<T*>;

Especializaciones estándar para los tipos de bibliotecas

std::hash<std::string>std::hash<std::u16string>std::hash<std::u32string>std::hash<std::wstring> (C++11)(C++11)(C++11)(C++11)	apoyo hash de cadenas Original: hash support for strings The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (especialización de plantilla de clase)
std::hash<std::error_code> (C++11)	apoyo hash para std::error_code Original: hash support for std::error_code The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (especialización de plantilla de clase)
std::hash<std::bitset> (C++11)	apoyo hash para std::bitset Original: hash support for std::bitset The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (especialización de plantilla de clase)
std::hash<std::unique_ptr> (C++11)	apoyo hash para std::unique_ptr Original: hash support for std::unique_ptr The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (especialización de plantilla de clase)
std::hash<std::shared_ptr> (C++11)	apoyo hash para std::shared_ptr Original: hash support for std::shared_ptr The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (especialización de plantilla de clase)
std::hash<std::type_index> (C++11)	apoyo hash para std::type_index Original: hash support for std::type_index The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (especialización de plantilla de clase)
std::hash<std::vector<bool>> (C++11)	apoyo hash para std::vector<bool> Original: hash support for std::vector<bool> The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (especialización de plantilla de clase)
std::hash<std::thread::id> (C++11)	apoyo hash para std::thread::id Original: hash support for std::thread::id The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (especialización de plantilla de clase)

Ejemplos

Demuestra el cálculo de un valor hash para std::string, un tipo que ya tiene una especialización Hash .

Original:

Demonstrates the computation of a hash for std::string, a type that already has a hash specialization.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

#include <iostream>
#include <functional>
#include <string>
 
int main()
{
    std::string str = "Meet the new boss...";
    std::hash<std::string> hash_fn;
    size_t str_hash = hash_fn(str);
 
    std::cout << str_hash << '\n';
}

Salida:

391070135

Demuestra la creación de una función hash para un tipo definido por el usuario. Usando esto como un parámetro de plantilla para std::unordered_map, std::unordered_set, etc también requiere una especialización de std::equal_to .

Original:

Demonstrates creation of a hash function for a user defined type. Using this as a template parameter for std::unordered_map, std::unordered_set, etc. also requires specialization of std::equal_to.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

#include <iostream>
#include <functional>
#include <string>
 
struct S {
    std::string first_name;
    std::string last_name;
};
 
template<class T> class MyHash;
 
template<>
class MyHash<S> {
public:
    size_t operator()(const S &s) const 
    {
        size_t h1 = std::hash<std::string>()(s.first_name);
        size_t h2 = std::hash<std::string>()(s.last_name);
        return h1 ^ (h2 << 1);
    }
};
 
int main()
{
    std::string s1 = "Hubert";
    std::string s2 = "Farnsworth";
    std::hash<std::string> h1;
 
    S n1;
    n1.first_name = s1;
    n1.last_name =  s2;
 
    std::cout << "hash(s1) = " << h1(s1) << "\n"
              << "hash(s2) = " << std::hash<std::string>()(s2) << "\n"
	      << "hash(n1) = " << MyHash<S>()(n1) << "\n";
 
}

Salida:

hash(s1) = 6119893563398376542
hash(s2) = 14988020022735710972
hash(n1) = 17649170831080298918

Muestra cómo especializarse std::hash para un tipo definido por el usuario .

Original:

Demonstrates how to specialize std::hash for a user defined type.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

#include <iostream>
#include <functional>
#include <string>
 
struct S {
    std::string first_name;
    std::string last_name;
};
 
namespace std {
template<>
class hash<S> {
public:
    size_t operator()(const S &s) const 
    {
        size_t h1 = std::hash<std::string>()(s.first_name);
        size_t h2 = std::hash<std::string>()(s.last_name);
        return h1 ^ ( h2 << 1 );
    }
};
}
 
int main()
{
    S s;
    s.first_name = "Bender";
    s.last_name =  "Rodriguez";
    std::hash<S> hash_fn;
 
    std::cout << "hash(s) = " << hash_fn(s) << "\n";
}

Salida:

hash(s) = 32902390710