Espaces de noms
Variantes
Affichages
Actions

std::hash

De cppreference.com
< cpp‎ | utility


Defined in header <functional>
template< class Key >
struct hash; // not defined
(depuis C++11)
Le modèle de hachage définit un objet qui implémente une fonction fonction de hachage. Instances de cet objet de définir une fonction operator() que:
Original:
The hash template defines a function object that implements a fonction de hachage. 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. Accepte un seul paramètre de type .. 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. Renvoie une valeur de size_t type qui représente la valeur de hachage du paramètre .
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. Ne pas lever des exceptions en cas d'appel .
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. Pour deux paramètres k1 et k2 qui sont égaux, 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. Pour deux paramètres différents k1 et k2 qui ne sont pas égales, la probabilité que std::hash<Key>()(k1) == std::hash<Key>()(k2) devrait être très faible, se rapprochant 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.
Le modèle de hachage est à la fois CopyConstructible et 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.
Le non-ordonnée des conteneurs associatifs std::unordered_set, std::unordered_multiset, std::unordered_map, std::unordered_multimap utiliser spécialisations de la std::hash modèle que la fonction de hachage par défaut .
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.

Sommaire

[modifier] Types de membres

argument_type Key
result_type std::size_t

[modifier] Fonctions membres

construit un objet fonction de hachage
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.

(fonction membre publique)
calculer l'empreinte de l'argument
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.

(fonction membre publique)

[modifier] Spécialisations standard pour les types de base

Defined in header <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*>;

[modifier] Spécialisations standard pour les types de bibliothèques

soutien de hachage pour cordes
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.

(classe générique spécialisée) [edit]
soutien de hachage pour 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.

(classe générique spécialisée) [edit]
soutien de hachage pour 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.

(classe générique spécialisée) [edit]
soutien de hachage pour 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.

(classe générique spécialisée) [edit]
Support du hachage pour std::shared_ptr
(classe générique spécialisée) [edit]
soutien de hachage pour 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.

(classe générique spécialisée) [edit]
soutien de hachage pour 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.

(classe générique spécialisée)
soutien de hachage pour 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.

(classe générique spécialisée)

[modifier] Exemples

Démontre le calcul de hachage pour un std::string, un type qui a déjà une spécialisation de hachage .

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';
}

Résultat :

391070135

Démontre création d'une fonction de hachage pour un type défini par l'utilisateur. L'utilisation de ce paramètre comme un modèle pour std::unordered_map, std::unordered_set, etc exige également la spécialisation des 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";
 
}

Résultat :

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

Montre comment se spécialiser std::hash pour un type défini par l'utilisateur .

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";
}

Résultat :

hash(s) = 32902390710