La classe `hash_map`

Article
10/12/2023

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Stocke et récupère des données rapidement auprès d’une collection dans laquelle chaque élément est une paire qui a une clé de tri dont la valeur est unique et une valeur de données associée.

Syntaxe

template <class Key,
    class Type,
    class Traits=hash_compare<Key, less<Key>>,
    class Allocator=allocator<pair <const Key, Type>>>
class hash_map

Paramètres

Key
Type de données clé à stocker dans le hash_map.

Type
Type de données d'élément à stocker dans le hash_map.

Traits
Type qui inclut deux objets de fonction, l’une des classes compare capable de comparer deux valeurs d’élément en tant que clés de tri pour déterminer leur ordre relatif et une fonction de hachage qui est une prédicat unaire mappant les valeurs de clé de mappage des éléments à des entiers non signés de type size_t. Cet argument est facultatif et hash_compare<Key, less<Key>> est la valeur par défaut.

Allocator
Type qui représente l’objet d’allocateur stocké qui encapsule des détails sur l’allocation et la désallocation de la hash_mapmémoire. Cet argument est facultatif et sa valeur par défaut est allocator<pair <const Key, Type>>.

Notes

Le hash_map est :

Un conteneur associatif de taille variable qui prend en charge la récupération efficace des valeurs d'éléments selon une valeur de clé associée.
Réversible, car elle fournit un itérateur bidirectionnel pour accéder à ses éléments
Haché, car ses éléments sont regroupés dans des compartiments selon la valeur d'une fonction de hachage appliquée aux valeurs de clé des éléments.
Unique dans le sens où chacun de ses éléments doit avoir une clé unique.
Un conteneur associatif de paires, car ses valeurs de données d'éléments sont séparées de ses valeurs de clés.
Un modèle de classe, car la fonctionnalité qu’elle fournit est générique et donc indépendante du type spécifique de données contenues sous forme d’éléments ou de clés. Les types de données utilisés pour les éléments et les clés sont eux spécifiés comme paramètres dans la classe de modèle avec la fonction de comparaison et l'allocateur.

Le principal avantage du hachage sur le tri est une meilleure efficacité : un hachage réussi effectue des insertions, des suppressions et trouve ce qui est recherché dans un délai moyen constant, alors que pour les techniques de tri, ce délai est proportionnel au logarithme du nombre d'éléments du conteneur. La valeur d’un élément dans un hash_mapélément, mais pas sa valeur de clé associée, peut être modifiée directement. Les valeurs de clés associées aux anciens éléments doivent être supprimées, et de nouvelles valeurs de clés doivent être associées aux nouveaux éléments insérés.

Le choix du type de conteneur doit être basé en général sur le type de la recherche et de l'insertion requis par l'application. Les conteneurs associatifs hachés sont optimisés pour les opérations de recherche, d'insertion et de suppression. Les fonctions membres qui prennent en charge explicitement ces opérations sont efficaces quand elles sont utilisées avec une fonction de hachage bien conçue, car elles les exécutent dans un délai qui est en moyenne constant et ne dépend pas du nombre d'éléments dans le conteneur. Une fonction de hachage bien conçue produit une distribution uniforme des valeurs de hachage et réduit le nombre de collisions, qui se produisent quand des valeurs de clés distinctes sont mappées dans la même valeur de hachage. Dans le pire des cas, avec la pire des fonctions de hachage possible, le nombre d'opérations est proportionnel au nombre d'éléments de la séquence (délai linéaire).

Il hash_map doit s’agir du conteneur associatif de choix lorsque les conditions associant les valeurs à leurs clés sont satisfaites par l’application. Un modèle pour ce type de structure est une liste ordonnée de mots clés uniques avec des valeurs de chaîne associées qui fournissent par exemple des définitions. Si, au lieu de cela, les mots avaient plusieurs définitions correctes, de sorte que les clés n’étaient pas uniques, il hash_multimap s’agirait du conteneur de choix. Si, d’autre part, seule la liste des mots était stockée, il hash_set s’agirait du conteneur approprié. Si plusieurs occurrences des mots étaient autorisées, il hash_multiset s’agirait de la structure de conteneur appropriée.

Commande hash_map la séquence qu’il contrôle en appelant un objet de hachage Traits stocké de classe value_compare. Cet objet stocké est accessible en appelant la fonction key_compmembre. Un tel objet de fonction doit se comporter comme un objet de classe hash_compare<Key, less<Key>>. En particulier, pour toutes les valeurs Key de type Key, l’appel Traits( Key ) génère une distribution des valeurs de type size_t. Pour plus d’informations, consultez hash_compare.

En général, les éléments doivent être simplement moins que comparables pour établir cet ordre : pour que, compte tenu de deux éléments, il peut être déterminé qu’ils sont équivalents (dans le sens où aucun n’est inférieur à l’autre) ou qu’un élément est inférieur à l’autre. Cela entraîne le tri des éléments non équivalents. D’un point de vue plus technique, la fonction de comparaison est un prédicat binaire qui induit un ordre faible strict au sens mathématique du terme. Un prédicat binaire f(x,y) est un objet de fonction qui a deux objets d'argument x et y, et une valeur de retour true ou false. Un ordre imposé à un hash_map est un ordre faible strict si le prédicat binaire est irréflexif, antisymmétrique et transitif et si l’équivalence est transitive, où deux objets x et y sont définis pour être équivalents lorsque f(x, y) et f(y, x) sont false. Si la plus élevée des conditions d'égalité entre les clés remplace celle de l'équivalence, alors le tri devient total (dans le sens où tous les éléments sont classés les uns par rapport aux autres), et les clés correspondantes seront alors impossibles à différencier les unes des autres.

L'ordre réel des éléments de la séquence contrôlée dépend de la fonction de hachage, de la fonction d'ordonnancement et de la taille actuelle de la table de hachage stockée dans l'objet conteneur. Vous ne pouvez pas déterminer la taille actuelle de la table de hachage. Vous ne pouvez donc pas prédire en général l’ordre des éléments dans la séquence contrôlée. L'insertion d'éléments ne rend aucun itérateur non valide. La suppression d'éléments rend uniquement non valides les itérateurs qui pointaient spécifiquement vers les éléments supprimés.

L’itérateur fourni par la hash_map classe est un itérateur bidirectionnel, mais les fonctions insert membres de classe et hash_map ont des versions qui prennent comme paramètres de modèle un itérateur d’entrée plus faible, dont les exigences de fonctionnalité sont plus minimales que celles garanties par la classe d’itérateurs bidirectionnels. Les différents concepts d'itérateurs forment une famille liée par les améliorations de leurs fonctionnalités. Chaque concept d'itérateur possède son propre ensemble de spécifications, et les algorithmes qui fonctionnent avec eux doivent limiter leurs hypothèses aux spécifications fournies par ce type d'itérateur. On peut considérer qu'un itérateur d'entrée peut être déréférencé pour faire référence à un objet et qu'il peut être incrémenté à l'itérateur suivant dans la séquence. Il s’agit d’un ensemble minimal de fonctionnalités, mais il suffit de pouvoir parler de manière significative d’une plage d’itérateurs [First, Last) dans le contexte des fonctions membres de classe.

Constructeurs

Constructeur	Description
`hash_map`	Construit un `hash_map` vide ou une copie de l'ensemble ou d'une partie d'un autre `hash_map`.

Typedefs

Nom de type	Description
`allocator_type`	Type qui représente la classe `allocator` pour l'objet `hash_map`.
`const_iterator`	Type qui fournit un itérateur bidirectionnel capable de lire un élément `const` dans le `hash_map`.
`const_pointer`	Type qui fournit un pointeur vers un élément `const` dans un `hash_map`.
`const_reference`	Type qui fournit une référence à un élément `const` stocké dans un `hash_map` pour la lecture et l'exécution des opérations `const`.
`const_reverse_iterator`	Type qui fournit un itérateur bidirectionnel capable de lire n'importe quel élément `const` dans le `hash_map`.
`difference_type`	Type entier signé qui peut être utilisé pour représenter le nombre d'éléments d'un `hash_map` au sein d'une plage, parmi les éléments pointés par les itérateurs.
`iterator`	Type qui fournit un itérateur bidirectionnel, qui peut lire ou modifier tout élément d'un objet `hash_map`.
`key_compare`	Type qui fournit un objet de fonction pouvant comparer deux clés de tri pour déterminer l'ordre relatif de deux éléments au sein d'un `hash_map`.
`key_type`	Type qui décrit l'objet de clé de tri qui constitue chaque élément de la classe `hash_map`.
`mapped_type`	Type qui représente le type de données stocké dans un `hash_map`.
`pointer`	Type qui fournit un pointeur vers un élément d'un objet `hash_map`.
`reference`	Type qui fournit une référence à un élément stocké dans un `hash_map`.
`reverse_iterator`	Type qui fournit un itérateur bidirectionnel capable de lire ou de modifier tout élément d'un `hash_map` inversé.
`size_type`	Type entier non signé qui peut représenter le nombre d'éléments dans un `hash_map`.
`value_type`	Type qui fournit un objet de fonction pouvant comparer deux éléments comme clés de tri pour déterminer leur ordre relatif dans le `hash_map`.

Fonctions Membre

Fonction membre	Description
`at`	Recherche un élément dans un objet `hash_map` avec une valeur de clé spécifiée.
`begin`	Retourne un itérateur traitant le premier élément d'un `hash_map`.
`cbegin`	Retourne un itérateur const qui traite le premier élément d'un `hash_map`.
`cend`	Retourne un itérateur const qui traite l'emplacement situé après le dernier élément d'un `hash_map`.
`clear`	Efface tous les éléments d'un `hash_map`.
`count`	Retourne le nombre d'éléments d'un `hash_map` dont la clé correspond à une clé spécifiée par un paramètre.
`crbegin`	Retourne un `const` itérateur qui traite le premier élément d’un élément inversé `hash_map`.
`crend`	Retourne un `const` itérateur qui traite l’emplacement qui réussit le dernier élément d’un élément inversé `hash_map`.
`emplace`	Insère un élément construit sur place dans un `hash_map`.
`emplace_hint`	Insère un élément construit sur place dans un `hash_map`, avec un indicateur de positionnement.
`empty`	Vérifie si un `hash_map` est vide.
`end`	Retourne un itérateur qui traite l'emplacement suivant le dernier élément d'un `hash_map`.
`equal_range`	Retourne une paire d'itérateurs, respectivement vers le premier élément d'un objet `hash_map` avec une clé supérieure à une clé spécifiée, et vers le premier élément d'un objet `hash_map` avec une clé supérieure ou égale à la clé.
`erase`	Supprime un élément ou une plage d'éléments aux positions spécifiées d'un objet `hash_map`.
`find`	Retourne un itérateur qui référence l'emplacement d'un élément d'un objet `hash_map` qui a une clé équivalente à une clé spécifiée.
`get_allocator`	Retourne une copie de l'objet `allocator` utilisé pour construire le `hash_map`.
`insert`	Insère un élément ou une plage d'éléments dans un `hash_map`.
`key_comp`	Retourne un itérateur pointant vers le premier élément d'un objet `hash_map` qui a une valeur de clé supérieure ou égale à celle d'une clé spécifiée.
`lower_bound`	Retourne un itérateur pointant vers le premier élément d'un objet `hash_map` qui a une valeur de clé supérieure ou égale à celle d'une clé spécifiée.
`max_size`	Retourne la longueur maximale du `hash_map`.
`rbegin`	Retourne un itérateur qui traite le premier élément d'un `hash_map` inversé.
`rend`	Retourne un itérateur qui traite l'emplacement suivant le dernier élément d'un `hash_map` inversé.
`size`	Retourne le nombre d'éléments d'un `hash_map`.
`swap`	Échange les éléments de deux `hash_map`.
`upper_bound`	Retourne un itérateur pointant vers le premier élément d'un objet `hash_map` qui a une valeur de clé supérieure à celle d'une clé spécifiée.
`value_comp`	Récupère une copie de l'objet de comparaison utilisé pour ordonner les valeurs des éléments d'un objet `hash_map`.

Opérateurs

Opérateur	Description
`operator[]`	Insère un élément dans un objet `hash_map` avec une valeur de clé spécifiée.
`hash_map::operator=`	Remplace les éléments d'un `hash_map` par une copie d'un autre `hash_map`.

Spécifications

En-tête : <hash_map>

Espace de noms : stdext

`hash_map::allocator_type`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type représentant la classe allocator pour l’objet hash_map.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::allocator_type allocator_type;

Exemple

Pour obtenir un exemple d’utilisationallocator_type, consultez l’exemple get_allocator .

`hash_map::at`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Recherche un élément dans un objet hash_map avec une valeur de clé spécifiée.

Type& at(const Key& key);

const Type& at(const Key& key) const;

Paramètres

key
Valeur de clé de l’élément à rechercher.

Valeur de retour

Référence à la valeur de données de l'élément trouvé.

Notes

Si la valeur de clé d’argument est introuvable, la fonction lève un objet de classeout_of_range.

Exemple

// hash_map_at.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;

   // Insert data values
   hm1.insert ( cInt2Int ( 1, 10 ) );
   hm1.insert ( cInt2Int ( 2, 20 ) );
   hm1.insert ( cInt2Int ( 3, 30 ) );

   cout  << "The values of the mapped elements are:";
   for ( int i = 1 ; i <= hm1.size() ; i++ )
      cout << " " << hm1.at(i);
   cout << "." << endl;
}

`hash_map::begin`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne un itérateur traitant le premier élément d'un hash_map.

const_iterator begin() const;

iterator begin();

Valeur de retour

Itérateur bidirectionnel qui traite le premier élément du ou de l’emplacement hash_map qui réussit un itérateur bidirectionnel hash_map.

Exemple

// hash_map_begin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 0, 0 ) );
   hm1.insert ( Int_Pair ( 1, 1 ) );
   hm1.insert ( Int_Pair ( 2, 4 ) );

   hm1_cIter = hm1.begin ( );
   cout << "The first element of hm1 is "
        << hm1_cIter -> first << "." << endl;

   hm1_Iter = hm1.begin ( );
   hm1.erase ( hm1_Iter );

   // The following 2 lines would err because the iterator is const
   // hm1_cIter = hm1.begin ( );
   // hm1.erase ( hm1_cIter );

   hm1_cIter = hm1.begin( );
   cout << "The first element of hm1 is now "
        << hm1_cIter -> first << "." << endl;
}

The first element of hm1 is 0.
The first element of hm1 is now 1.

`hash_map::cbegin`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne un itérateur const qui traite le premier élément d'un hash_map.

const_iterator cbegin() const;

Valeur de retour

Itérateur bidirectionnel const ciblant le premier élément dans le hash_map ou l’emplacement qui réussit un itérateur bidirectionnel vide hash_map.

Exemple

// hash_map_cbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 2, 4 ) );

   hm1_cIter = hm1.cbegin ( );
   cout << "The first element of hm1 is "
        << hm1_cIter -> first << "." << endl;
   }

The first element of hm1 is 2.

`hash_map::cend`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne un itérateur const qui traite l'emplacement situé après le dernier élément d'un hash_map.

const_iterator cend() const;

Valeur de retour

Itérateur bidirectionnel const qui traite l’emplacement qui réussit le dernier élément d’un hash_map. Si le hash_map est vide, hash_map::cend == hash_map::begin.

Notes

cend est utilisé pour déterminer si un itérateur a atteint la fin de son hash_map.

La valeur retournée par cend ne doit pas être déréférencement.

Exemple

// hash_map_cend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_cIter = hm1.cend( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is "
        << hm1_cIter -> second << "." << endl;
   }

The value of last element of hm1 is 30.

`hash_map::clear`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Efface tous les éléments d'un hash_map.

void clear();

Notes

Exemple

L’exemple suivant illustre l’utilisation de la hash_map::clear fonction membre.

// hash_map_clear.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 1));
    hm1.insert(Int_Pair(2, 4));

    i = hm1.size();
    cout << "The size of the hash_map is initially "
         << i << "." << endl;

    hm1.clear();
    i = hm1.size();
    cout << "The size of the hash_map after clearing is "
         << i << "." << endl;
}

The size of the hash_map is initially 2.
The size of the hash_map after clearing is 0.

`hash_map::const_iterator`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type qui fournit un itérateur bidirectionnel capable de lire un élément const dans le hash_map.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_iterator const_iterator;

Notes

Un type const_iterator ne peut pas être utilisé pour modifier la valeur d’un élément.

Défini const_iterator par hash_map des points vers des éléments qui sont des objets de value_type, qui est de type pair< const Key, Type >, dont le premier membre est la clé de l’élément et dont le deuxième membre est la référence mappée détenue par l’élément.

Pour déréférencer un const_iterator cIter pointant vers un élément dans un hash_map, utilisez l’opérateur -> .

Pour accéder à la valeur de la clé de l’élément, utilisez cIter->first, ce qui équivaut à (*cIter).first. Pour accéder à la valeur de la référence mappée pour l’élément, utilisez cIter->second, ce qui équivaut à (*cIter).second.

Exemple

Pour obtenir un exemple d’utilisationconst_iterator, consultez l’exemple begin .

`hash_map::const_pointer`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type qui fournit un pointeur vers un élément const dans un hash_map.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_pointer const_pointer;

Notes

Un type const_pointer ne peut pas être utilisé pour modifier la valeur d’un élément.

Dans la plupart des cas, un iterator doit être utilisé pour accéder aux éléments d’un hash_map objet.

`hash_map::const_reference`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type qui fournit une référence à un élément const stocké dans un hash_map pour la lecture et l'exécution des opérations const.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_reference const_reference;

Notes

Exemple

// hash_map_const_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map<int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( hm1.begin( ) -> first );

   // The following line would cause an error because the
   // non-const_reference cannot be used to access the key
   // int &Ref1 = ( hm1.begin( ) -> first );

   cout << "The key of the first element in the hash_map is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( hm1.begin( ) -> second );

   cout << "The data value of the first element in the hash_map is "
        << Ref2 << "." << endl;
}

The key of the first element in the hash_map is 1.
The data value of the first element in the hash_map is 10.

`hash_map::const_reverse_iterator`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type qui fournit un itérateur bidirectionnel capable de lire n'importe quel élément const dans le hash_map.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reverse)iterator const_reverse_iterator;

Notes

Un type const_reverse_iterator ne peut pas modifier la valeur d’un élément et est utilisé pour itérer à travers l’inverse hash_map .

Défini const_reverse_iterator par hash_map des points vers des éléments qui sont des objets de value_type, qui est de type pair< const Key, Type >, dont le premier membre est la clé de l’élément et dont le deuxième membre est la référence mappée détenue par l’élément.

Pour déréférencer un const_reverse_iterator crIter pointant vers un élément dans un hash_map, utilisez l’opérateur -> .

Pour accéder à la valeur de la clé de l’élément, utilisez crIter->first, ce qui équivaut à (*crIter).first. Pour accéder à la valeur de la référence mappée pour l’élément, utilisez crIter->second, ce qui équivaut à (*crIter).first.

Exemple

Consultez l’exemple pour rend obtenir un exemple de déclaration et d’utilisation du const_reverse_iteratorfichier .

`hash_map::count`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne le nombre d'éléments d'un hash_map dont la clé correspond à une clé spécifiée par un paramètre.

size_type count(const Key& key) const;

Paramètres

key
Valeur clé des éléments à mettre en correspondance à partir du hash_map.

Valeur de retour

1 si le conteneur contient un élément dont la hash_map clé de tri correspond à la clé de paramètre ; 0 si elle hash_map ne contient pas d’élément avec une clé correspondante.

Notes

La fonction membre retourne le nombre d’éléments x dans la plage

lower_bound(key), upper_bound(key)

qui est 0 ou 1 dans le cas de hash_map, qui est un conteneur associatif unique.

Exemple

L’exemple suivant illustre l’utilisation de la hash_map::count fonction membre.

// hash_map_count.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair (1, 1));
    hm1.insert(Int_Pair (2, 1));
    hm1.insert(Int_Pair (1, 4));
    hm1.insert(Int_Pair (2, 1));

    // Keys must be unique in hash_map, so duplicates are ignored
    i = hm1.count(1);
    cout << "The number of elements in hm1 with a sort key of 1 is: "
         << i << "." << endl;

    i = hm1.count(2);
    cout << "The number of elements in hm1 with a sort key of 2 is: "
         << i << "." << endl;

    i = hm1.count(3);
    cout << "The number of elements in hm1 with a sort key of 3 is: "
         << i << "." << endl;
}

The number of elements in hm1 with a sort key of 1 is: 1.
The number of elements in hm1 with a sort key of 2 is: 1.
The number of elements in hm1 with a sort key of 3 is: 0.

`hash_map::crbegin`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne un const itérateur qui traite le premier élément d’un élément inversé hash_map.

const_reverse_iterator crbegin() const;

Valeur de retour

Itérateur const bidirectionnel inverse ciblant le premier élément d’un élément inversé hash_map ou traitant ce qui avait été le dernier élément de l’inversion hash_map.

Notes

crbegin est utilisé avec un inverse hash_map comme begin utilisé avec un hash_map.

Avec la valeur de retour de crbegin, l’objet hash_map ne peut pas être modifié.

Vous pouvez utiliser crbegin pour itérer un objet hash_map vers l’arrière.

Exemple

// hash_map_crbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_crIter = hm1.crbegin( );
   cout << "The first element of the reversed hash_map hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The first element of the reversed hash_map hm1 is 3.

`hash_map::crend`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne un const itérateur qui traite l’emplacement qui réussit le dernier élément d’un élément inversé hash_map.

const_reverse_iterator crend() const;

Valeur de retour

Itérateur const bidirectionnel inverse qui traite l’emplacement qui réussit le dernier élément d’un inverse (emplacement qui avait précédé le premier élément dans l’élément non hash_mapinversé hash_map ).

Notes

crend est utilisé avec un inverse hash_map comme hash_map::end utilisé avec un hash_map.

Avec la valeur de retour de crend, l’objet hash_map ne peut pas être modifié.

crend peut être utilisé pour déterminer si un itérateur inversé a atteint la fin de son objet hash_map.

La valeur retournée par crend ne doit pas être déréférencement.

Exemple

// hash_map_crend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_crIter = hm1.crend( );
   hm1_crIter--;
   cout << "The last element of the reversed hash_map hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The last element of the reversed hash_map hm1 is 3.

`hash_map::difference_type`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type entier signé qui peut être utilisé pour représenter le nombre d'éléments d'un hash_map au sein d'une plage, parmi les éléments pointés par les itérateurs.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::difference_type difference_type;

Exemple

// hash_map_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_map>
#include <algorithm>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 3, 20 ) );

   // The following won't insert, because map keys are unique
   hm1.insert ( Int_Pair ( 2, 30 ) );

   hash_map <int, int>::iterator hm1_Iter, hm1_bIter, hm1_eIter;
   hm1_bIter = hm1.begin( );
   hm1_eIter = hm1.end( );

   // Count the number of elements in a hash_map
   hash_map <int, int>::difference_type  df_count = 0;
   hm1_Iter = hm1.begin( );
   while ( hm1_Iter != hm1_eIter)
   {
      df_count++;
      hm1_Iter++;
   }

   cout << "The number of elements in the hash_map hm1 is: "
        << df_count << "." << endl;

   cout  << "The keys of the mapped elements are:";
   for ( hm1_Iter= hm1.begin( ) ; hm1_Iter!= hm1.end( ) ;
         hm1_Iter++)
      cout << " " << hm1_Iter-> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( hm1_Iter= hm1.begin( ) ; hm1_Iter!= hm1.end( ) ;
         hm1_Iter++)
      cout << " " << hm1_Iter-> second;
   cout << "." << endl;
}

The number of elements in the hash_map hm1 is: 3.
The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 20.

`hash_map::emplace`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Insère un élément construit sur place dans un hash_map.

template <class ValTy>
pair <iterator, bool>
emplace(
    ValTy&& val);

Paramètres

val
Valeur utilisée pour déplacer un élément à insérer dans l’élément hash_map , sauf si l’élément contient déjà cet élément (ou, plus généralement, un élément dont la hash_map clé est ordonnée de manière équivalente).

Valeur de retour

La emplace fonction membre retourne une paire dont bool le composant retourne true si une insertion a été effectuée et false si l’élément hash_map contient déjà une valeur équivalente dans l’ordre, et dont iterator le composant retourne l’adresse où un nouvel élément a été inséré ou où l’élément était déjà situé.

Pour accéder au composant iterator d’une paire pr retournée par cette fonction membre, utilisez pr.first et, pour le déréférencer, utilisez *(pr.first). Pour accéder au composant bool d’une paire pr retournée par cette fonction membre, utilisez pr.second et, pour le déréférencer, utilisez *(pr.second).

Notes

L’élément hash_map::value_type est une paire, de sorte que la valeur d’un élément sera une paire ordonnée avec le premier composant égal à la valeur de clé et le deuxième composant égal à la valeur de données de l’élément.

Exemple

// hash_map_emplace.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(move(is1));
    cout << "After the emplace insertion, hm1 contains:" << endl
      << " " << hm1.begin()->first
      << " => " << hm1.begin()->second
      << endl;
}

After the emplace insertion, hm1 contains:
1 => a

`hash_map::emplace_hint`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Insère un élément construit sur place dans un hash_map, avec un indicateur de positionnement.

template <class ValTy>
iterator emplace_hint(
    const_iterator _Where,
    ValTy&& val);

Paramètres

c
Indicateur concernant l’emplacement où commencer à rechercher le point d’insertion correct.

Valeur de retour

La hash_multimap::emplace fonction membre retourne un itérateur qui pointe vers la position où le nouvel élément a été inséré dans le hash_map, ou où se trouve l’élément existant avec un ordre équivalent.

Notes

L’insertion peut se produire dans le temps fixe amorti, plutôt que dans le temps logarithmique, si le point d’insertion suit immédiatement _Where.

Exemple

// hash_map_emplace_hint.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(hm1.begin(), move(is1));
    cout << "After the emplace, hm1 contains:" << endl
      << " " << hm1.begin()->first
      << " => " << hm1.begin()->second
      << endl;
}

After the emplace insertion, hm1 contains:
1 => a

`hash_map::empty`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Vérifie si un hash_map est vide.

bool empty() const;

Valeur de retour

true si la hash_map valeur est vide ; false si elle hash_map n’est pas vide.

Notes

Exemple

// hash_map_empty.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1, hm2;

   typedef pair <int, int> Int_Pair;
   hm1.insert ( Int_Pair ( 1, 1 ) );

   if ( hm1.empty( ) )
      cout << "The hash_map hm1 is empty." << endl;
   else
      cout << "The hash_map hm1 is not empty." << endl;

   if ( hm2.empty( ) )
      cout << "The hash_map hm2 is empty." << endl;
   else
      cout << "The hash_map hm2 is not empty." << endl;
}

The hash_map hm1 is not empty.
The hash_map hm2 is empty.

`hash_map::end`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne un itérateur qui traite l'emplacement suivant le dernier élément d'un hash_map.

const_iterator end() const;

iterator end();

Valeur de retour

Itérateur bidirectionnel qui traite l’emplacement qui réussit le dernier élément d’un hash_map. Si le hash_map est vide, hash_map::end == hash_map::begin.

Notes

end est utilisé pour déterminer si un itérateur a atteint la fin de son hash_map.

La valeur retournée par end ne doit pas être déréférencement.

Exemple

// hash_map_end.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_cIter = hm1.end( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is "
        << hm1_cIter -> second << "." << endl;

   hm1_Iter = hm1.end( );
   hm1_Iter--;
   hm1.erase ( hm1_Iter );

   // The following 2 lines would err because the iterator is const
   // hm1_cIter = hm1.end ( );
   // hm1_cIter--;
   // hm1.erase ( hm1_cIter );

   hm1_cIter = hm1.end( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is now "
        << hm1_cIter -> second << "." << endl;
}

The value of last element of hm1 is 30.
The value of last element of hm1 is now 20.

`hash_map::equal_range`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne une paire d'itérateurs, respectivement vers le premier élément d'un objet hash_map avec une clé supérieure à une clé spécifiée, et vers le premier élément d'un objet hash_map avec une clé supérieure ou égale à la clé.

pair <const_iterator, const_iterator> equal_range (const Key& key) const;

pair <iterator, iterator> equal_range (const Key& key);

Paramètres

key
Valeur de clé d’argument à comparer à la clé de tri d’un élément à partir de l’objet hash_map recherché.

Valeur de retour

Une paire d’itérateurs de sorte que la première est la lower_bound clé et que la seconde est la upper_bound clé.

Pour accéder au premier itérateur d’une paire pr retournée par la fonction membre, utilisez pr.first et déférez l’itérateur lié inférieur, utilisez *(pr.first). Pour accéder au deuxième itérateur d’une paire pr retournée par la fonction membre, utilisez pr.second et déréférez l’itérateur lié supérieur, utilisez *(pr.second).

Notes

Exemple

// hash_map_equal_range.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_map <int, int> IntMap;
   IntMap hm1;
   hash_map <int, int> :: const_iterator hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   pair <IntMap::const_iterator, IntMap::const_iterator> p1, p2;
   p1 = hm1.equal_range( 2 );

   cout << "The lower bound of the element with "
        << "a key of 2 in the hash_map hm1 is: "
        << p1.first -> second << "." << endl;

   cout << "The upper bound of the element with "
        << "a key of 2 in the hash_map hm1 is: "
        << p1.second -> second << "." << endl;

   // Compare the upper_bound called directly
   hm1_RcIter = hm1.upper_bound( 2 );

   cout << "A direct call of upper_bound( 2 ) gives "
        << hm1_RcIter -> second << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 2 )." << endl;

   p2 = hm1.equal_range( 4 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == hm1.end( ) ) && ( p2.second == hm1.end( ) ) )
      cout << "The hash_map hm1 doesn't have an element "
             << "with a key less than 40." << endl;
   else
      cout << "The element of hash_map hm1 with a key >= 40 is: "
           << p1.first -> first << "." << endl;
}

The lower bound of the element with a key of 2 in the hash_map hm1 is: 20.
The upper bound of the element with a key of 2 in the hash_map hm1 is: 30.
A direct call of upper_bound( 2 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 2 ).
The hash_map hm1 doesn't have an element with a key less than 40.

`hash_map::erase`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Supprime d'un emplacement spécifié un élément ou une plage d'éléments compris dans un hash_map ou supprime les éléments qui correspondent à une clé spécifiée.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Paramètres

_Where
Position de l’élément à supprimer du hash_map.

first
Position du premier élément supprimé du hash_map.

last
Position juste au-delà du dernier élément supprimé du hash_map.

key
Valeur clé des éléments à supprimer du hash_map.

Valeur de retour

Pour les deux premières fonctions membres, itérateur bidirectionnel qui désigne le premier élément restant au-delà des éléments supprimés, ou un pointeur vers la fin du hash_map cas où aucun élément de ce type n’existe.

Pour la troisième fonction membre, retourne le nombre d’éléments qui ont été supprimés du hash_map.

Notes

Les fonctions membres ne lèvent jamais d'exception.

Exemple

L’exemple suivant illustre l’utilisation de la hash_map::erase fonction membre.

// hash_map_erase.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1, hm2, hm3;
    hash_map<int, int> :: iterator pIter, Iter1, Iter2;
    int i;
    hash_map<int, int>::size_type n;
    typedef pair<int, int> Int_Pair;

    for (i = 1; i < 5; i++)
    {
        hm1.insert(Int_Pair (i, i));
        hm2.insert(Int_Pair (i, i*i));
        hm3.insert(Int_Pair (i, i-1));
    }

    // The 1st member function removes an element at a given position
    Iter1 = ++hm1.begin();
    hm1.erase(Iter1);

    cout << "After the 2nd element is deleted, the hash_map hm1 is:";
    for (pIter = hm1.begin(); pIter != hm1.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 2nd member function removes elements
    // in the range [ first,  last)
    Iter1 = ++hm2.begin();
    Iter2 = --hm2.end();
    hm2.erase(Iter1, Iter2);

    cout << "After the middle two elements are deleted, "
         << "the hash_map hm2 is:";
    for (pIter = hm2.begin(); pIter != hm2.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 3rd member function removes elements with a given  key
    n = hm3.erase(2);

    cout << "After the element with a key of 2 is deleted,\n"
         << "the hash_map hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 3rd member function returns the number of elements removed
    cout << "The number of elements removed from hm3 is: "
         << n << "." << endl;

    // The dereferenced iterator can also be used to specify a key
    Iter1 = ++hm3.begin();
    hm3.erase(Iter1);

    cout << "After another element with a key equal to that"
         << endl;
    cout  << "of the 2nd element is deleted, "
          << "the hash_map hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;
}

After the 2nd element is deleted, the hash_map hm1 is: 1 3 4.
After the middle two elements are deleted, the hash_map hm2 is: 1 16.
After the element with a key of 2 is deleted,
the hash_map hm3 is: 0 2 3.
The number of elements removed from hm3 is: 1.
After another element with a key equal to that
of the 2nd element is deleted, the hash_map hm3 is: 0 3.

`hash_map::find`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne un itérateur qui référence l'emplacement d'un élément d'un objet hash_map qui a une clé équivalente à une clé spécifiée.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Paramètres

key
Valeur de clé à mettre en correspondance par la clé de tri d’un élément à partir de la hash_map recherche en cours.

Valeur de retour

Itérateur qui traite l’emplacement d’un élément avec une clé spécifiée ou l’emplacement qui réussit le dernier élément dans le hash_map cas où aucune correspondance n’est trouvée pour la clé.

Notes

find retourne un itérateur qui traite un élément dans la hash_map clé de tri dont la clé de tri équivaut à la clé d’argument sous un prédicat binaire qui induise un classement basé sur une relation inférieure à celle de la milliseconde.

Si la valeur de retour d’un find objet est affectée à un const_iterator, l’objet hash_map ne peut pas être modifié. Si la valeur de retour d’un find objet est affectée à un iterator, l’objet hash_map peut être modifié

Exemple

// hash_map_find.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.find( 2 );
   cout << "The element of hash_map hm1 with a key of 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   hm1_RcIter = hm1.find( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_map can be found
   // using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.end( );
   hm1_AcIter--;
   hm1_RcIter = hm1.find( hm1_AcIter -> first );
   cout << "The element of hm1 with a key matching "
        << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;
}

The element of hash_map hm1 with a key of 2 is: 20.
The hash_map hm1 doesn't have an element with a key of 4.
The element of hm1 with a key matching that of the last element is: 30.

`hash_map::get_allocator`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne une copie de l’objet allocator utilisé pour construire le hash_map.

Allocator get_allocator() const;

Valeur de retour

Allocator utilisé par le hash_map.

Notes

Les allocateurs de la hash_map classe spécifient la façon dont la classe gère le stockage. Les allocateurs par défaut fournis avec les classes de conteneur de bibliothèque C++ Standard suffisent à satisfaire la plupart des besoins en programmation. L'écriture et l'utilisation de votre propre classe d'allocateur font l'objet d'une rubrique avancée du langage C++.

Exemple

// hash_map_get_allocator.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int>::allocator_type hm1_Alloc;
   hash_map <int, int>::allocator_type hm2_Alloc;
   hash_map <int, double>::allocator_type hm3_Alloc;
   hash_map <int, int>::allocator_type hm4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   hash_map <int, int> hm1;
   hash_map <int, int> hm2;
   hash_map <int, double> hm3;

   hm1_Alloc = hm1.get_allocator( );
   hm2_Alloc = hm2.get_allocator( );
   hm3_Alloc = hm3.get_allocator( );

   cout << "The number of integers that can be allocated"
        << endl << "before free memory is exhausted: "
        << hm2.max_size( ) << "." << endl;

   cout << "The number of doubles that can be allocated"
        << endl << "before free memory is exhausted: "
        << hm3.max_size( ) <<  "." << endl;

   // The following line creates a hash_map hm4
   // with the allocator of hash_map hm1.
   hash_map <int, int> hm4( less<int>( ), hm1_Alloc );

   hm4_Alloc = hm4.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated with the other
   if( hm1_Alloc == hm4_Alloc )
   {
      cout << "The allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "The allocators are not interchangeable."
           << endl;
   }
}

`hash_map::hash_map`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Construit un hash_map qui est vide ou est une copie de tout ou partie d’un autre hash_map.

hash_map();

explicit hash_map(
    const Traits& Comp);

hash_map(
    const Traits& Comp,
    const Allocator& Al);

hash_map(
    const hash_map& Right);

hash_map(
    hash_map&& Right);

hash_map(
    initializer_list<Type> IList);hash_map(initializer_list<Type> IList,
    const key_compare& Comp);

hash_map(
    initializer_list<Type> IList,
    const key_compare& Comp,
    const allocator_type& Al);

template <class InputIterator>
hash_map(
    InputIterator First,
    InputIterator Last);

template <class InputIterator>
hash_map(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp);

template <class InputIterator>
hash_map(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp,
    const Allocator& Al

Paramètres

Al
Classe d’allocateur de stockage à utiliser pour cet objet hash_map, qui est par défaut Allocator.

Comp
Fonction de comparaison de type const Traits utilisée pour classer les éléments dans le hash_map, qui a la hash_comparevaleur par défaut .

Right
Dont hash_map la carte construite doit être une copie.

First
Position du premier élément de la plage d'éléments à copier.

Last
Position du premier élément au-delà de la plage d'éléments à copier.

IList
initializer_list.

Notes

Tous les constructeurs stockent un type d’objet allocator qui gère le stockage de mémoire pour l’objet hash_map et peuvent être retournés ultérieurement en appelant get_allocator. Le paramètre d’allocateur est souvent omis dans les déclarations de classe, et des macros de prétraitement sont utilisées pour substituer des allocateurs de remplacement.

Tous les constructeurs initialisent leur hash_map.

Tous les constructeurs stockent un objet de fonction de type Traits utilisé pour établir un ordre entre les clés du hash_map et qui peuvent être retournés ultérieurement en appelant key_comp.

Les trois premiers constructeurs spécifient un initial hash_mapvide, en outre, le second spécifie le type de fonction de comparaison (Comp) à utiliser pour établir l’ordre des éléments et le troisième spécifie explicitement le type d’allocateur (Al) à utiliser. Le mot clé explicit supprime certains genres de conversions de type automatiques.

Le quatrième constructeur spécifie une copie du hash_map Right.

Les trois constructeurs suivants copient la plage [First, Last) d’un hash_map avec une précision croissante en spécifiant le type de fonction de comparaison de classe Traits et d’allocateur.

Le dernier constructeur déplace le hash_map Right.

`hash_map::insert`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Insère un élément ou une plage d'éléments dans un hash_map.

pair <iterator, bool> insert(
    const value_type& val);

iterator insert(
    const_iterator _Where,
    const value_type& val);

template <class InputIterator>
void insert(
    InputIterator first,
    InputIterator last);

template <class ValTy>
pair <iterator, bool>
insert(
    ValTy&& val);

template <class ValTy>
iterator insert(
    const_iterator _Where,
    ValTy&& val);

Paramètres

val
Valeur d’un élément à insérer dans le hash_map sauf si l’élément contient déjà cet élément (ou, plus généralement, un élément dont la hash_map clé est ordonnée de manière équivalente).

_Where
Indicateur concernant l’emplacement où commencer à rechercher le point d’insertion correct.

first
Position du premier élément à copier à partir d’un hash_map.

last
Position juste au-delà du dernier élément à copier à partir d’un hash_map.

Valeur de retour

La première insert fonction membre retourne une paire dont bool le composant retourne true si une insertion a été effectuée et false si l’élément contient déjà un élément dont la hash_map clé avait une valeur équivalente dans l’ordre, et dont le composant itérateur retourne l’adresse où un nouvel élément a été inséré ou où l’élément était déjà situé.

Pour accéder au composant itérateur d’une paire pr retournée par cette fonction membre, utilisez pr.first et, pour le déréférencer, utilisez (pr.first). Pour accéder au composant bool d’une paire pr retournée par cette fonction membre, utilisez pr.second et, pour le déréférencer, utilisez \(pr.second).

La deuxième insert fonction membre, la version de l’indicateur, retourne un itérateur qui pointe vers la position où le nouvel élément a été inséré dans le hash_map.

Les deux insert dernières fonctions membres se comportent de la même façon que les deux premières, sauf qu’elles déplacent la valeur insérée.

Notes

L’élément value_type est une paire, de sorte que la valeur d’un élément sera une paire ordonnée avec le premier composant égal à la valeur de clé et le deuxième composant égal à la valeur de données de l’élément.

L’insertion peut se produire dans le temps fixe amorti pour la version d’indicateur d’insert, plutôt que dans le temps logarithmique, si le point d’insertion suit immédiatement _Where.

La troisième fonction membre insère la séquence de valeurs d’élément dans un hash_map élément correspondant à chaque élément traité par un itérateur de la plage *[First, Last)* d’un jeu spécifié.

Exemple

// hash_map_insert.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int>::iterator hm1_pIter, hm2_pIter;

    hash_map<int, int> hm1, hm2;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 10));
    hm1.insert(Int_Pair(2, 20));
    hm1.insert(Int_Pair(3, 30));
    hm1.insert(Int_Pair(4, 40));

    cout << "The original elements (Key => Value) of hm1 are:";
    for (hm1_pIter = hm1.begin(); hm1_pIter != hm1.end(); hm1_pIter++)
        cout << endl << " " << hm1_pIter -> first << " => "
             << hm1_pIter->second;
    cout << endl;

    pair< hash_map<int,int>::iterator, bool > pr;
    pr = hm1.insert(Int_Pair(1, 10));

    if (pr.second == true)
    {
        cout << "The element 10 was inserted in hm1 successfully."
            << endl;
    }
    else
    {
        cout << "The element 10 already exists in hm1\n"
            << "with a key value of "
            << "((pr.first) -> first) = " << (pr.first)->first
            << "." << endl;
    }

    // The hint version of insert
    hm1.insert(--hm1.end(), Int_Pair(5, 50));

    cout << "After the insertions, the elements of hm1 are:";
    for (hm1_pIter = hm1.begin(); hm1_pIter != hm1.end(); hm1_pIter++)
        cout << endl << hm1_pIter -> first << " => "
             << hm1_pIter->second;
    cout << endl;

    hm2.insert(Int_Pair(10, 100));

    // The templatized version inserting a range
    hm2.insert( ++hm1.begin(), --hm1.end() );

    cout << "After the insertions, the elements of hm2 are:";
    for (hm2_pIter = hm2.begin(); hm2_pIter != hm2.end(); hm2_pIter++)
        cout << endl << hm2_pIter -> first << " => "
             << hm2_pIter->second;
    cout << endl;

    // The templatized versions move constructing elements
    hash_map<int, string> hm3, hm4;
    pair<int, string> is1(1, "a"), is2(2, "b");

    hm3.insert(move(is1));
    cout << "After the move insertion, hm3 contains:" << endl
      << hm3.begin()->first
      << " => " << hm3.begin()->second
      << endl;

    hm4.insert(hm4.begin(), move(is2));
    cout << "After the move insertion, hm4 contains:" << endl
      << hm4.begin()->first
      << " => " << hm4.begin()->second
      << endl;
}

The original elements (Key => Value) of hm1 are:
1 => 10
2 => 20
3 => 30
4 => 40
The element 10 already exists in hm1
with a key value of ((pr.first) -> first) = 1.
After the insertions, the elements of hm1 are:
1 => 10
2 => 20
3 => 30
4 => 40
5 => 50
After the insertions, the elements of hm2 are:
2 => 20
10 => 100
3 => 30
4 => 40
After the move insertion, hm3 contains:
1 => a
After the move insertion, hm4 contains:
2 => b

`hash_map::iterator`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type qui fournit un itérateur bidirectionnel, qui peut lire ou modifier tout élément d'un objet hash_map.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::iterator iterator;

Notes

Défini iterator par hash_map des points vers des éléments qui sont des objets de value_type, qui est de type pair<const Key, Type>, dont le premier membre est la clé de l’élément et dont le deuxième membre est la référence mappée détenue par l’élément.

Pour déréférencer un itérateur nommé Iter pointant vers un élément d’un multimap, utilisez l’opérateur -> .

Pour accéder à la valeur de la clé de l’élément, utilisez Iter->first, ce qui équivaut à (*Iter).first. Pour accéder à la valeur de la référence mappée pour l’élément, utilisez Iter->second, ce qui équivaut à (*Iter).second.

Un type iterator peut être utilisé pour modifier la valeur d’un élément.

Exemple

Pour obtenir un exemple begin de déclaration et d’utilisation de l’objet iterator.

`hash_map::key_comp`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Récupère une copie de l'objet de comparaison utilisé pour trier les clés au sein d'un hash_map.

key_compare key_comp() const;

Valeur de retour

Retourne l’objet de fonction qu’un hash_map utilisateur utilise pour classer ses éléments.

Notes

L’objet stocké définit la fonction membre

bool operator( const Key& left, const Key&right );

qui retourne true si left précède et n’est pas égal à right dans l’ordre de tri.

Exemple

// hash_map_key_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_map <int, int, hash_compare<int, less<int> > > hm1;
   hash_map <int, int, hash_compare<int, less<int> > >::key_compare
      kc1 = hm1.key_comp( ) ;

   // Operator stored in kc1 tests order & returns bool value
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true,"
           << "\n where kc1 is the function object of hm1"
           << " of type key_compare." << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false"
           << "\n where kc1 is the function object of hm1"
           << " of type key_compare." << endl;
   }

   hash_map <int, int, hash_compare<int, greater<int> > > hm2;
   hash_map <int, int, hash_compare<int, greater<int> > >
      ::key_compare kc2 = hm2.key_comp( );

   // Operator stored in kc2 tests order & returns bool value
   bool result2 = kc2( 2, 3 ) ;
   if( result2 == true )
   {
      cout << "kc2( 2,3 ) returns value of true,"
           << "\n where kc2 is the function object of hm2"
           << " of type key_compare." << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false,"
           << "\n where kc2 is the function object of hm2"
           << " of type key_compare." << endl;
   }
}

`hash_map::key_compare`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type qui fournit un objet de fonction pouvant comparer deux clés de tri pour déterminer l’ordre relatif de deux éléments dans la classe map.

typedef Traits key_compare;

Notes

key_compare est un synonyme du paramètre de modèle Traits.

Pour plus d’informations sur Traits la hash_map rubrique Classe .

Exemple

Consultez l’exemple pour key_comp obtenir un exemple de déclaration et d’utilisation key_compare.

`hash_map::key_type`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type qui décrit l'objet de clé de tri qui constitue chaque élément de la classe hash_map.

typedef Key key_type;

Notes

key_type est un synonyme du paramètre de modèle Key.

Pour plus d’informations sur Key, consultez la section Remarques de la hash_map rubrique Classe .

Exemple

Consultez l’exemple pour value_type obtenir un exemple de déclaration et d’utilisation key_type.

`hash_map::lower_bound`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne un itérateur pointant vers le premier élément d'un objet hash_map qui a une valeur de clé supérieure ou égale à celle d'une clé spécifiée.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Paramètres

key
Valeur de clé d’argument à comparer à la clé de tri d’un élément à partir de l’objet hash_map recherché.

Valeur de retour

const_iterator Ou iterator qui traite l’emplacement d’un élément dans un hash_map élément avec une clé égale ou supérieure à la clé d’argument, ou qui traite l’emplacement qui réussit le dernier élément dans le hash_map cas où aucune correspondance n’est trouvée pour la clé.

Si la valeur de retour d’un lower_bound objet est affectée à un const_iterator, l’objet hash_map ne peut pas être modifié. Si la valeur de retour d’un lower_bound objet est affectée à un iterator, l’objet hash_map peut être modifié.

Notes

Exemple

// hash_map_lower_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.lower_bound( 2 );
   cout << "The first element of hash_map hm1 with a key of 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   hm1_RcIter = hm1. lower_bound ( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // An element at a specific location in the hash_map can be
   // found using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.end( );
   hm1_AcIter--;
   hm1_RcIter = hm1. lower_bound ( hm1_AcIter -> first );
   cout << "The element of hm1 with a key matching "
        << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;
}

The first element of hash_map hm1 with a key of 2 is: 20.
The hash_map hm1 doesn't have an element with a key of 4.
The element of hm1 with a key matching that of the last element is: 30.

`hash_map::mapped_type`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type qui représente le type de données stocké dans un hash_map.

typedef Type mapped_type;

Notes

Le type mapped_type est un synonyme du paramètre de modèle Type.

Pour plus d’informations sur Type la hash_map rubrique Classe .

Exemple

Consultez l’exemple pour value_type obtenir un exemple de déclaration et d’utilisation key_type.

`hash_map::max_size`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne la longueur maximale du hash_map.

size_type max_size() const;

Valeur de retour

Longueur maximale possible du hash_map.

Notes

Exemple

// hash_map_max_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: size_type i;

   i = hm1.max_size( );
   cout << "The maximum possible length "
        << "of the hash_map is " << i << "."
        << endl << "(Magnitude is machine specific.)";
}

`hash_map::operator[]`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Insère un élément dans un objet hash_map avec une valeur de clé spécifiée.

Type& operator[](const Key& key);

Type& operator[](Key&& key);

Paramètres

key
Valeur de clé de l’élément à insérer.

Valeur de retour

Référence à la valeur de données de l'élément inséré.

Notes

Si la valeur de clé d’argument est introuvable, elle est insérée avec la valeur par défaut du type de données.

Vous pouvez utiliser operator[] pour insérer des éléments dans un hash_map m à l’aide de

m[ key] = DataValue;

où DataValue est la valeur du mapped_type de l’élément avec une valeur de clé de key.

Lorsque vous utilisez operator[] pour insérer des éléments, la référence retournée n’indique pas si une insertion change un élément préexistant ou en crée un nouveau. Les fonctions find membres et insert peuvent être utilisées pour déterminer si un élément avec une clé spécifiée est déjà présent avant une insertion.

Exemple

// hash_map_op_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;
   hash_map <int, int> :: iterator pIter;

   // Insert a data value of 10 with a key of 1
   // into a hash_map using the operator[] member function
   hm1[ 1 ] = 10;

   // Compare other ways to insert objects into a hash_map
   hm1.insert ( hash_map <int, int> :: value_type ( 2, 20 ) );
   hm1.insert ( cInt2Int ( 3, 30 ) );

   cout  << "The keys of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;

   // If the key already exists, operator[]
   // changes the value of the datum in the element
   hm1[ 2 ] = 40;

   // operator[] will also insert the value of the data
   // type's default constructor if the value is unspecified
   hm1[5];

   cout  << "The keys of the mapped elements are now:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are now:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;

   // operator[] will also insert by moving a key
   hash_map <string, int> hm2;
   string str("a");
   hm2[move(str)] = 1;
   cout << "The moved key is " << hm2.begin()->first
      << ", with value " << hm2.begin()->second << endl;
}

`hash_map::operator=`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Remplace les éléments de l'objet hash_map par une copie d'un autre objet hash_map.

hash_map& operator=(const hash_map& right);

hash_map& operator=(hash_map&& right);

Paramètres

right
Classe right copiée dans le hash_map.

Notes

Après avoir supprimé les éléments existants dans un objet hash_map, operator= copie ou déplace le contenu de right dans hash_map.

Exemple

// hash_map_operator_as.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map<int, int> v1, v2, v3;
   hash_map<int, int>::iterator iter;

   v1.insert(pair<int, int>(1, 10));

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << iter->second << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter->second << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter->second << " ";
   cout << endl;
}

`hash_map::pointer`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type qui fournit un pointeur vers un élément d'un objet hash_map.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::pointer pointer;

Notes

Un type pointer peut être utilisé pour modifier la valeur d’un élément.

Dans la plupart des cas, un iterator doit être utilisé pour accéder aux éléments d’un hash_map objet.

`hash_map::rbegin`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne un itérateur qui traite le premier élément d'un hash_map inversé.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valeur de retour

Itérateur bidirectionnel inverse ciblant le premier élément d’un élément inversé hash_map ou traitant ce qui avait été le dernier élément de l’inversion hash_map.

Notes

rbegin est utilisé avec un inverse hash_map comme begin utilisé avec un hash_map.

Si la valeur de retour d’un rbegin objet est affectée à un const_reverse_iterator, l’objet hash_map ne peut pas être modifié. Si la valeur de retour d’un rbegin objet est affectée à un reverse_iterator, l’objet hash_map peut être modifié.

Vous pouvez utiliser rbegin pour itérer un objet hash_map vers l’arrière.

Exemple

// hash_map_rbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: reverse_iterator hm1_rIter;
   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_rIter = hm1.rbegin( );
   cout << "The first element of the reversed hash_map hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_map in a forward order
   cout << "The hash_map is: ";
   for ( hm1_Iter = hm1.begin( ) ; hm1_Iter != hm1.end( ); hm1_Iter++)
      cout << hm1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a hash_map in a reverse order
   cout << "The reversed hash_map is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_map element can be erased by dereferencing to its key
   hm1_rIter = hm1.rbegin( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed hash_map is "
        << hm1_rIter -> first << "." << endl;
}

The first element of the reversed hash_map hm1 is 3.
The hash_map is: 1 2 3 .
The reversed hash_map is: 3 2 1 .
After the erasure, the first element in the reversed hash_map is 2.

`hash_map::reference`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type qui fournit une référence à un élément stocké dans un hash_map.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::reference reference;

Notes

Exemple

// hash_map_reference.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( hm1.begin( ) -> first );

   // The following line would cause an error as the
   // non-const_reference cannot be used to access the key
   // int &Ref1 = ( hm1.begin( ) -> first );

   cout << "The key of first element in the hash_map is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( hm1.begin( ) -> second );

   cout << "The data value of first element in the hash_map is "
        << Ref2 << "." << endl;

   // The non-const_reference can be used to modify the
   // data value of the first element
   Ref2 = Ref2 + 5;
   cout << "The modified data value of first element is "
        << Ref2 << "." << endl;
}

The key of first element in the hash_map is 1.
The data value of first element in the hash_map is 10.
The modified data value of first element is 15.

`hash_map::rend`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne un itérateur qui traite l'emplacement suivant le dernier élément d'un hash_map inversé.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valeur de retour

Itérateur bidirectionnel inverse qui traite l’emplacement qui réussit le dernier élément d’un inverse (emplacement qui avait précédé le premier élément dans l’élément non hash_mapinversé hash_map ).

Notes

rend est utilisé avec un inverse hash_map comme end utilisé avec un hash_map.

Si la valeur de retour d’un rend objet est affectée à un const_reverse_iterator, l’objet hash_map ne peut pas être modifié. Si la valeur de retour d’un rend objet est affectée à un reverse_iterator, l’objet hash_map peut être modifié.

rend peut être utilisé pour déterminer si un itérateur inversé a atteint la fin de son objet hash_map.

La valeur retournée par rend ne doit pas être déréférencement.

Exemple

// hash_map_rend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: reverse_iterator hm1_rIter;
   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_rIter = hm1.rend( );
   hm1_rIter--;
   cout << "The last element of the reversed hash_map hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_map in a forward order
   cout << "The hash_map is: ";
   for ( hm1_Iter = hm1.begin( ) ; hm1_Iter != hm1.end( );
   hm1_Iter++)
      cout << hm1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a hash_map in a reverse order
   cout << "The reversed hash_map is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( );
      hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_map element can be erased by dereferencing to its key
   hm1_rIter = --hm1.rend( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rend( );
   hm1_rIter--;
   cout << "After the erasure, the last element "
        << "in the reversed hash_map is "
        << hm1_rIter -> first << "." << endl;
}

The last element of the reversed hash_map hm1 is 1.
The hash_map is: 1 2 3 .
The reversed hash_map is: 3 2 1 .
After the erasure, the last element in the reversed hash_map is 2.

`hash_map::reverse_iterator`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type qui fournit un itérateur bidirectionnel capable de lire ou de modifier tout élément d'un hash_map inversé.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::reverse_iterator reverse_iterator;

Notes

Un type reverse_iterator ne peut pas modifier la valeur d’un élément et est utilisé pour itérer à travers l’inverse hash_map .

Défini reverse_iterator par hash_map des points vers des éléments qui sont des objets de value_type, c’est-à-dire de type pair<const Key, Type>, dont le premier membre est la clé de l’élément et dont le deuxième membre est le datum mappé détenu par l’élément.

Pour déréférencer un reverse_iterator rIter pointant vers un élément dans un hash_map, utilisez l’opérateur -> .

Pour accéder à la valeur de la clé de l’élément, utilisez rIter->first, ce qui équivaut à (*rIter).first. Pour accéder à la valeur de la référence mappée pour l’élément, utilisez rIter->second, ce qui équivaut à (*rIter).first.

Exemple

Consultez l’exemple pour rbegin obtenir un exemple de déclaration et d’utilisation reverse_iterator.

`hash_map::size`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne le nombre d'éléments d'un hash_map.

size_type size() const;

Valeur de retour

Longueur actuelle du hash_map.

Notes

Exemple

L’exemple suivant illustre l’utilisation de la hash_map::size fonction membre.

// hash_map_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1, hm2;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 1));
    i = hm1.size();
    cout << "The hash_map length is " << i << "." << endl;

    hm1.insert(Int_Pair(2, 4));
    i = hm1.size();
    cout << "The hash_map length is now " << i << "." << endl;
}

The hash_map length is 1.
The hash_map length is now 2.

`hash_map::size_type`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type entier non signé qui peut représenter le nombre d'éléments dans un hash_map.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::size_type size_type;

Notes

Exemple

Voir un exemple pour size obtenir un exemple de déclaration et d’utilisation size_type

`hash_map::swap`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Échange les éléments de deux hash_map.

void swap(hash_map& right);

Paramètres

right
Argument hash_map fournissant les éléments à permuter avec la cible hash_map.

Notes

La fonction membre invalide aucune référence, pointeur ou itérateur qui désigne les éléments dans les deux hash_maps dont les éléments sont échangés.

Exemple

// hash_map_swap.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1, hm2, hm3;
   hash_map <int, int>::iterator hm1_Iter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );
   hm2.insert ( Int_Pair ( 10, 100 ) );
   hm2.insert ( Int_Pair ( 20, 200 ) );
   hm3.insert ( Int_Pair ( 30, 300 ) );

   cout << "The original hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;

   // This is the member function version of swap
   // hm2 is said to be the argument hash_map;
   // hm1 is said to be the target hash_map
   hm1.swap( hm2 );

   cout << "After swapping with hm2, hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hm1, hm3 );

   cout << "After swapping with hm3, hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;
}

The original hash_map hm1 is: 10 20 30.
After swapping with hm2, hash_map hm1 is: 100 200.
After swapping with hm3, hash_map hm1 is: 300.

`hash_map::upper_bound`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne un itérateur au premier élément d’une hash_map clé dont la valeur est supérieure à celle d’une clé spécifiée.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Paramètres

key
Valeur de clé d’argument à comparer à la valeur de clé de tri d’un élément à partir de la hash_map recherche en cours.

Valeur de retour

const_iterator Ou iterator qui traite l’emplacement d’un élément dans un hash_map élément avec une clé supérieure à la clé d’argument, ou qui traite l’emplacement qui réussit le dernier élément dans le hash_map cas où aucune correspondance n’est trouvée pour la clé.

Si la valeur de retour est affectée à un const_iteratorobjet, l’objet hash_map ne peut pas être modifié. Si la valeur de retour est affectée à un iteratorobjet, l’objet hash_map peut être modifié.

Notes

Exemple

// hash_map_upper_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.upper_bound( 2 );
   cout << "The first element of hash_map hm1 with a key "
        << "greater than 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end is returned
   hm1_RcIter = hm1. upper_bound ( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key greater than 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key > 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_map can be found
   // using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.begin( );
   hm1_RcIter = hm1. upper_bound ( hm1_AcIter -> first );
   cout << "The 1st element of hm1 with a key greater than that\n"
        << "of the initial element of hm1 is: "
        << hm1_RcIter -> second << "." << endl;
}

The first element of hash_map hm1 with a key greater than 2 is: 30.
The hash_map hm1 doesn't have an element with a key greater than 4.
The 1st element of hm1 with a key greater than that
of the initial element of hm1 is: 20.

`hash_map::value_comp`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Retourne un objet de fonction qui détermine l’ordre des éléments dans un hash_map en comparant leurs valeurs de clé.

value_compare value_comp() const;

Valeur de retour

Retourne l’objet de fonction de comparaison qu’un hash_map utilise pour classer ses éléments.

Notes

Pour un hash_map m, si deux éléments e1 (k1, d1) et e2 (k2, d2) sont des objets de type value_type, où k1 et k2 sont leurs clés de type key_type et d2 d1 sont leurs données de type mapped_type, alors m.value_comp()(e1, e2) est équivalent à m.key_comp()(k1, k2). Un objet stocké définit la fonction membre

bool operator(value_type& left, value_type& right);

qui retourne true si la valeur de clé des left précédes et n’est pas égale à la valeur de clé de l’ordre de right tri.

Exemple

// hash_map_value_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_map <int, int, hash_compare<int, less<int> > > hm1;
   hash_map <int, int, hash_compare<int, less<int> > >
   ::value_compare vc1 = hm1.value_comp( );
   pair< hash_map<int,int>::iterator, bool > pr1, pr2;

   pr1= hm1.insert ( hash_map <int, int> :: value_type ( 1, 10 ) );
   pr2= hm1.insert ( hash_map <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *pr1.first, *pr2.first ) == true )
   {
      cout << "The element ( 1,10 ) precedes the element ( 2,5 )."
           << endl;
   }
   else
   {
      cout << "The element ( 1,10 ) does not precede the element ( 2,5 )."
           << endl;
   }

   if( vc1 ( *pr2.first, *pr1.first ) == true )
   {
      cout << "The element ( 2,5 ) precedes the element ( 1,10 )."
           << endl;
   }
   else
   {
      cout << "The element ( 2,5 ) does not precede the element ( 1,10 )."
           << endl;
   }
}

`hash_map::value_type`

Remarque

Cette API est obsolète. L’alternative est unordered_map Class.

Type qui représente le type d’objet stocké dans un hash_map.

typedef pair<const Key, Type> value_type;

Notes

value_type est déclaré comme pair<const key_type, mapped_type> étant et non pair<key_type, mapped_type> parce que les clés d’un conteneur associatif peuvent ne pas être modifiées à l’aide d’un itérateur ou d’une référence nonconstant.

Exemple

// hash_map_value_type.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;
   hash_map <int, int> :: key_type key1;
   hash_map <int, int> :: mapped_type mapped1;
   hash_map <int, int> :: value_type value1;
   hash_map <int, int> :: iterator pIter;

   // value_type can be used to pass the correct type
   // explicitly to avoid implicit type conversion
   hm1.insert ( hash_map <int, int> :: value_type ( 1, 10 ) );

   // Compare other ways to insert objects into a hash_map
   hm1.insert ( cInt2Int ( 2, 20 ) );
   hm1[ 3 ] = 30;

   // Initializing key1 and mapped1
   key1 = ( hm1.begin( ) -> first );
   mapped1 = ( hm1.begin( ) -> second );

   cout << "The key of first element in the hash_map is "
        << key1 << "." << endl;

   cout << "The data value of first element in the hash_map is "
        << mapped1 << "." << endl;

   // The following line would cause an error because
   // the value_type is not assignable
   // value1 = cInt2Int ( 4, 40 );

   cout  << "The keys of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;
}

The key of first element in the hash_map is 1.
The data value of first element in the hash_map is 10.
The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 30.

Voir aussi

Sécurité des threads dans la bibliothèque C++ Standard
Informations de référence sur la bibliothèque standard C++

Partager via

La classe hash_map

Syntaxe

Paramètres

Notes

Constructeurs

Typedefs

Fonctions Membre

Opérateurs

Spécifications

hash_map::allocator_type

Exemple

hash_map::at

Paramètres

Valeur de retour

Notes

Exemple

hash_map::begin

Valeur de retour

Exemple

hash_map::cbegin

Valeur de retour

Exemple

hash_map::cend

Valeur de retour

Notes

Exemple

hash_map::clear

Notes

Exemple

hash_map::const_iterator

Notes

Exemple

hash_map::const_pointer

Notes

hash_map::const_reference

Notes

Exemple

hash_map::const_reverse_iterator

Notes

Exemple

hash_map::count

Paramètres

Valeur de retour

Notes

Exemple

hash_map::crbegin

Valeur de retour

Notes

Exemple

hash_map::crend

Valeur de retour

Notes

Exemple

hash_map::difference_type

Exemple

hash_map::emplace

Paramètres

Valeur de retour

Notes

Exemple

hash_map::emplace_hint

Paramètres

Valeur de retour

Notes

Exemple

hash_map::empty

Valeur de retour

Notes

Exemple

hash_map::end

Valeur de retour

Notes

Exemple

hash_map::equal_range

Paramètres

Valeur de retour

Notes

Exemple

hash_map::erase

La classe `hash_map`

`hash_map::allocator_type`

`hash_map::at`

`hash_map::begin`

`hash_map::cbegin`

`hash_map::cend`

`hash_map::clear`

`hash_map::const_iterator`

`hash_map::const_pointer`

`hash_map::const_reference`

`hash_map::const_reverse_iterator`

`hash_map::count`

`hash_map::crbegin`

`hash_map::crend`

`hash_map::difference_type`

`hash_map::emplace`

`hash_map::emplace_hint`

`hash_map::empty`

`hash_map::end`

`hash_map::equal_range`

`hash_map::erase`

`hash_map::find`

`hash_map::get_allocator`

`hash_map::hash_map`

`hash_map::insert`

`hash_map::iterator`

`hash_map::key_comp`

`hash_map::key_compare`

`hash_map::key_type`

`hash_map::lower_bound`

`hash_map::mapped_type`

`hash_map::max_size`

`hash_map::operator[]`

`hash_map::operator=`

`hash_map::pointer`

`hash_map::rbegin`

`hash_map::reference`

`hash_map::rend`

`hash_map::reverse_iterator`