Namespaces
Variants

std::type_info:: hash_code

From cppreference.net
C++
Utilities library
Type support
std::type_info
std:: size_t hash_code ( ) const noexcept ;
(depuis C++11)

Retourne une valeur non spécifiée (ici désignée par hash code ) telle que pour tous les objets std::type_info se référant au même type, leur hash code soit identique.

Aucune autre garantie n'est donnée : std::type_info les objets se référant à différents types peuvent avoir le même hash code (bien que la norme recommande que les implémentations évitent cela autant que possible), et le hash code pour le même type peut changer entre les invocations du même programme.

Table des matières

Paramètres

(aucun)

Valeur de retour

Une valeur identique pour tous les std::type_info objets faisant référence au même type.

Exemple

Le programme suivant est un exemple de mappage efficace type-valeur sans utiliser std::type_index .

Exécuter ce code 
#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <typeinfo>
#include <unordered_map>
struct A
{
    virtual ~A() {}
};
struct B : A {};
struct C : A {};
using TypeInfoRef = std::reference_wrapper<const std::type_info>;
struct Hasher
{
    std::size_t operator()(TypeInfoRef code) const
    {
        return code.get().hash_code();
    }
};
struct EqualTo
{
    bool operator()(TypeInfoRef lhs, TypeInfoRef rhs) const
    {
        return lhs.get() == rhs.get();
    }
};
int main()
{
    std::unordered_map<TypeInfoRef, std::string, Hasher, EqualTo> type_names;
    type_names[typeid(int)] = "int";
    type_names[typeid(double)] = "double";
    type_names[typeid(A)] = "A";
    type_names[typeid(B)] = "B";
    type_names[typeid(C)] = "C";
    int i;
    double d;
    A a;
    // note that we're storing pointer to type A
    std::unique_ptr<A> b(new B);
    std::unique_ptr<A> c(new C);
    std::cout << "i is " << type_names[typeid(i)] << '\n';
    std::cout << "d is " << type_names[typeid(d)] << '\n';
    std::cout << "a is " << type_names[typeid(a)] << '\n';
    std::cout << "*b is " << type_names[typeid(*b)] << '\n';
    std::cout << "*c is " << type_names[typeid(*c)] << '\n';
}

Sortie : 

i is int
d is double
a is A
*b is B
*c is C

Voir aussi

(removed in C++20)
vérifie si les objets font référence au même type
(fonction membre publique)
nom défini par l'implémentation du type
(fonction membre publique)