La classe `map`

Article
10/12/2023

Utilisé pour le stockage et la récupération de données d’une collection dans laquelle chaque élément est une paire qui a à la fois une valeur de données et une clé de tri. La valeur de la clé est unique et est utilisée pour trier automatiquement les données.

La valeur d'un élément dans une classe map peut être modifiée directement. La valeur de clé est une constante et ne peut pas être modifiée. Les valeurs de clés associées aux anciens éléments doivent être supprimées, et de nouvelles valeurs de clés doivent être insérées pour les nouveaux éléments.

Syntaxe

template <class Key,
    class Type,
    class Traits = less<Key>,
    class Allocator=allocator<pair <const Key, Type>>>
class map;

Paramètres

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

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

Traits
Type qui fournit un objet de fonction qui peut comparer deux valeurs d’élément en tant que clés de tri pour déterminer leur ordre relatif dans le map. Cet argument est facultatif et le prédicat binaire less<Key> est la valeur par défaut.

En C++14, vous pouvez activer la recherche hétérogène en spécifiant le std::less<> prédicat qui n’a aucun paramètre de type. Pour plus d’informations, consultez recherche hétérogène dans les conteneurs associatifs .

Allocator
Type qui représente l'objet allocateur stocké qui contient des informations sur l'allocation et la désallocation de mémoire de la classe map. Cet argument est facultatif et sa valeur par défaut est allocator<pair<const Key, Type> >.

Notes

La classe map de la bibliothèque standard C++ est :

Un conteneur de taille variable qui récupère efficacement des valeurs d'éléments selon les valeurs de clés associées.
Réversible, car elle fournit des itérateurs bidirectionnels pour accéder à ses éléments.
Trié, car ses éléments sont classés par valeurs de clés selon une fonction de comparaison spécifiée.
Unique, car 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 indépendante du type d’élément ou de clé. Les types de données utilisés pour des éléments et des clés sont spécifiés comme paramètres dans le modèle de classe avec la fonction de comparaison et l'allocateur.

L’itérateur fourni par la classe map est un itérateur bidirectionnel, mais les insert map fonctions membres de classe ont des versions qui prennent en tant que paramètres de modèle un itérateur d’entrée plus faible, dont les exigences de fonctionnalité sont inférieures à celles garanties par la classe d’itérateurs bidirectionnels. Les différents concepts d'itérateurs sont liés par des 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 lui doivent être limités par ces spécifications. Un itérateur d'entrée peut être déréférencé pour faire référence à un objet et peut être incrémenté à l'itérateur suivant de la séquence.

Nous vous recommandons de baser le choix du type de conteneur sur le type de recherche et d'insertion qui est requis par l'application. Les conteneurs associatifs sont optimisés pour les opérations de recherche, d'insertion et de suppression. Les fonctions membres qui prennent explicitement en charge ces opérations les font dans le pire des cas qui sont proportionnelles au logarithme du nombre d’éléments dans le conteneur. 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.

Nous vous recommandons de faire de la classe map le conteneur associatif de premier choix lorsque des conditions qui associent des valeurs avec des clés sont remplies par l'application. Un modèle pour ce type de structure est une liste triée de mots clés à occurrence unique avec des valeurs de chaîne associées qui fournissent des définitions. Si un mot a plusieurs définitions correctes, de sorte que cette clé n’est pas unique, un multimap serait le conteneur de choix. Si seule la liste de mots est stockée, il convient d'utiliser un ensemble comme conteneur. Si plusieurs occurrences de mots sont autorisées, il convient d'utiliser une classe multiset.

Le mappage commande les éléments qu’il contrôle en appelant un objet de fonction stocké de type key_compare. Cet objet stocké est une fonction de comparaison accessible en appelant la key_comp méthode. En général, deux éléments donnés sont comparés pour déterminer si l’un est inférieur à l’autre ou s’ils sont équivalents. Comme tous les éléments sont comparés, une séquence classée d'éléments non équivalents est créée.

Remarque

La fonction de comparaison est un prédicat binaire qui induit un ordre faible strict dans le sens mathématique du terme. Un prédicat binaire f(x,y) est un objet de fonction qui a deux objets d’arguments x et y, et la valeur de retour true ou false. Un ordre imposé sur un ensemble est un ordre faible strict si le prédicat binaire est irréflexif, antisymétrique et transitif, et si l’équivalence est transitive, où deux objets x et y sont définis pour être équivalents lorsque les deux objets 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.

En C++14, vous pouvez activer la recherche hétérogène en spécifiant le ou std::greater<> le std::less<> prédicat qui n’a aucun paramètre de type. Pour plus d’informations, consultez recherche hétérogène dans les conteneurs associatifs .

Membres

Constructeurs

Nom	Description
`map`	Construit une liste de taille spécifique ou contenant des éléments de valeurs spécifiques, ou contenant un `allocator` spécifique ou comme copie d'une autre classe map.

Typedefs

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

Fonctions Membre

Fonction membre	Description
`at`	Recherche un élément avec la valeur de clé spécifiée.
`begin`	Retourne un itérateur qui pointe vers le premier élément d'un `map`.
`cbegin`	Retourne un itérateur const qui pointe vers le premier élément du `map`.
`cend`	Retourne un itérateur const de type past-the-end.
`clear`	Efface tous les éléments d'un `map`.
`contains`^C++20	Vérifiez s’il existe un élément avec la clé spécifiée dans le `map`.
`count`	Retourne le nombre d'éléments dans une classe map dont la clé correspond à celle spécifiée dans un paramètre.
`crbegin`	Retourne un itérateur const qui pointe vers le premier élément d’un itérateur inversé `map`.
`crend`	Retourne un itérateur const qui pointe vers l’emplacement après le dernier élément d’un itérateur inversé `map`.
`emplace`	Insère un élément construit en place dans le `map`.
`emplace_hint`	Insère un élément construit en place dans le `map`, avec un indicateur de placement.
`empty`	Retourne `true` si une `map` valeur est vide.
`end`	Retourne l'itérateur past-the-end.
`equal_range`	Retourne une paire d'itérateurs. Le premier itérateur de la paire pointe vers le premier élément d'un `map` avec une clé qui est supérieure à celle spécifiée. Le deuxième itérateur de la paire pointe vers le premier élément du `map` avec une clé dont la valeur est supérieure ou égale à la clé spécifiée.
`erase`	Supprime un élément ou une plage d'éléments dans une classe map depuis les emplacement spécifiés.
`find`	Retourne un itérateur qui pointe vers l’emplacement d’un élément dans un `map` qui a une clé égale à une clé spécifiée.
`get_allocator`	Retourne une copie de l'objet `allocator` qui est utilisé pour construire le `map`.
`insert`	Insère un élément ou une plage d'éléments dans l'objet `map` à un emplacement spécifié.
`key_comp`	Retourne une copie de l’objet de comparaison utilisé pour classer les clés dans un `map`.
`lower_bound`	Retourne un itérateur au premier élément d’un `map` qui a une valeur de clé égale ou supérieure à celle d’une clé spécifiée.
`max_size`	Retourne la longueur maximale du `map`.
`rbegin`	Retourne un itérateur qui pointe vers le premier élément d'un `map` inversé.
`rend`	Retourne un itérateur qui pointe vers l’emplacement après le dernier élément d’un élément inversé `map`.
`size`	Retourne le nombre d'éléments d'un `map`.
`swap`	Échange les éléments de deux classes map.
`upper_bound`	Retourne un itérateur au premier élément d’une `map` 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 trier les valeurs d'éléments dans un `map`.

Opérateurs

Nom	Description
`operator[]`	Insère un élément dans une classe map avec une valeur de clé spécifiée.
`operator=`	Remplace les éléments d'une classe map par une copie d'une autre classe map.

`allocator_type`

Type qui représente la classe allocator pour l’objet map.

typedef Allocator allocator_type;

Exemple

Consultez l’exemple pour get_allocator obtenir un exemple qui utilise allocator_type.

`at`

Recherche un élément 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é à 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

// map_at.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

typedef std::map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// find and show elements
    std::cout << "c1.at('a') == " << c1.at('a') << std::endl;
    std::cout << "c1.at('b') == " << c1.at('b') << std::endl;
    std::cout << "c1.at('c') == " << c1.at('c') << std::endl;

    return (0);
    }

`begin`

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

const_iterator begin() const;

iterator begin();

Valeur de retour

Itérateur bidirectionnel qui traite le premier élément du ou de l’emplacement map qui réussit une carte vide.

Exemple

// map_begin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;

   map <int, int> :: iterator m1_Iter;
   map <int, int> :: const_iterator m1_cIter;
   typedef pair <int, int> Int_Pair;

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

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

   m1_Iter = m1.begin ( );
   m1.erase ( m1_Iter );

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

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

The first element of m1 is 0
The first element of m1 is now 1

`cbegin`

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

const_iterator cbegin() const;

Valeur de retour

Itérateur bidirectionnel const se rapportant au premier élément de la plage, ou emplacement situé juste après la fin d'une plage vide (pour une plage vide : cbegin() == cend()).

Notes

Avec la valeur de retour , les éléments de cbeginla plage ne peuvent pas être modifiés.

Vous pouvez utiliser cette fonction membre à la place de la fonction membre begin() afin de garantir que la valeur de retour est const_iterator. En règle générale, il est utilisé conjointement avec le mot clé de déduction de auto type, comme illustré dans l’exemple suivant. Dans cet exemple, Container est supposé être un conteneur modifiable (autre que const) de type indéfini prenant en charge begin() et cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`cend`

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

const_iterator cend() const;

Valeur de retour

Itérateur forward bidirectionnel const qui pointe juste après la fin de la plage.

Notes

cend est utilisé pour vérifier si un itérateur a dépassé la fin de la plage.

Vous pouvez utiliser cette fonction membre à la place de la fonction membre end() afin de garantir que la valeur de retour est const_iterator. En règle générale, il est utilisé conjointement avec le mot clé de déduction de auto type, comme illustré dans l’exemple suivant. Dans cet exemple, Container est supposé être un conteneur modifiable (autre que const) de type indéfini prenant en charge end() et cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

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

`clear`

Efface tous les éléments d'une classe map.

void clear();

Exemple

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

// map_clear.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main()
{
    using namespace std;
    map<int, int> m1;
    map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

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

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

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

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

`const_iterator`

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

typedef implementation-defined const_iterator;

Notes

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

Défini par le const_iterator mappage pointe vers des éléments qui sont des objets de value_type, qui est de type pair<constKey, 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érer une const_iterator cIter référence pointant vers un élément d’une carte, utilisez l’opérateur -> .

Pour accéder à la valeur de la clé de l’élément, utilisez cIter ->first, qui équivaut à (* cIter). first.

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

Exemple

Consultez l’exemple pour begin obtenir un exemple qui utilise const_iterator.

`const_pointer`

Type qui fournit un pointeur vers un const élément d’une carte.

typedef typename 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 objet map.

`const_reference`

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

typedef typename allocator_type::const_reference const_reference;

Exemple

// map_const_ref.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;
   typedef pair <int, int> Int_Pair;

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

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

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

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

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

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

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

`const_reverse_iterator`

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

typedef std::reverse_iterator<const_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 la carte en sens inverse.

Défini par le const_reverse_iterator mappage pointe 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 sur un élément dans une classe map, utilisez l’opérateur ->.

Pour accéder à la valeur de la clé de l’élément, utilisez crIter ->first, qui équivaut à (* crIter).first.

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

Exemple

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

`count`

Retourne le nombre d'éléments d'une classe 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 de clé des éléments à mettre en correspondance à partir de la classe map.

Valeur de retour

1 si la classe map contient un élément dont la clé de tri correspond à la clé du paramètre ; 0 si la classe 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 map, qui est un conteneur associatif unique.

Exemple

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

// map_count.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main()
{
    using namespace std;
    map<int, int> m1;
    map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

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

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

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

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

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

`contains`

Vérifie s’il existe un élément avec la clé spécifiée dans le map.

bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;

Paramètres

K
Type de la clé.

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

Valeur de retour

true si l’élément est trouvé dans le conteneur ; false autrement.

Notes

contains() est nouveau en C++20. Pour l’utiliser, spécifiez l’option du /std:c++20 compilateur ou ultérieure.

template<class K> bool contains(const K& key) const participe uniquement à la résolution de surcharge si key_compare elle est transparente. Pour plus d’informations, consultez recherche hétérogène dans les conteneurs associatifs .

Exemple

// Requires /std:c++20 or /std:c++latest
#include <map>
#include <string>
#include <iostream>
#include <functional>

int main()
{
    std::map<int, bool> m = {{0, true},{1, false}};

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << m.contains(1) << '\n';
    std::cout << m.contains(2) << '\n';

    // call template function
    std::map<std::string, int, std::less<>> m2 = {{"ten", 10}, {"twenty", 20}, {"thirty", 30}};
    std::cout << m2.contains("ten");

    return 0;
}

true
false
true

`crbegin`

Retourne un itérateur const qui traite le premier élément d’une classe map inversée.

const_reverse_iterator crbegin() const;

Valeur de retour

Itérateur bidirectionnel inverse const traitant le premier élément d’un inverse map ou traitant ce qui avait été le dernier élément dans l’inversion map.

Notes

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

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

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

Exemple

// map_crbegin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;

   map <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_crIter = m1.crbegin( );
   cout << "The first element of the reversed map m1 is "
        << m1_crIter -> first << "." << endl;
}

The first element of the reversed map m1 is 3.

`crend`

Retourne un itérateur const qui traite l’emplacement qui suit le dernier élément d’une classe map inversée.

const_reverse_iterator crend() const;

Valeur de retour

Itérateur bidirectionnel inverse const 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 mapinversé map ).

Notes

crend est utilisé avec une carte inversée tout comme end avec un map.

Avec la valeur de retour de crend, l’objet 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 map.

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

Exemple

// map_crend.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;

   map <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_crIter = m1.crend( );
   m1_crIter--;
   cout << "The last element of the reversed map m1 is "
        << m1_crIter -> first << "." << endl;
}

The last element of the reversed map m1 is 1.

`difference_type`

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

typedef allocator_type::difference_type difference_type;

Notes

difference_type est le type retourné durant la soustraction ou l'incrémentation via les itérateurs du conteneur. difference_type est généralement utilisé pour représenter le nombre d’éléments de la plage [ first, last) entre les itérateurs first et last. Il inclut l’élément vers lequel pointe first et la plage d’éléments allant jusqu’à l’élément (mais sans l’inclure) vers lequel pointe last.

Bien qu’il difference_type soit disponible pour tous les itérateurs qui répondent aux exigences d’un itérateur d’entrée, qui inclut la classe d’itérateurs bidirectionnels pris en charge par des conteneurs réversibles tels que définis, la soustraction entre itérateurs n’est prise en charge que par les itérateurs d’accès aléatoire fournis par un conteneur d’accès aléatoire tel que le vecteur.

Exemple

// map_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <map>
#include <algorithm>

int main( )
{
   using namespace std;
   map <int, int> m1;
   typedef pair <int, int> Int_Pair;

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

   map <int, int>::iterator m1_Iter, m1_bIter, m1_eIter;
   m1_bIter = m1.begin( );
   m1_eIter = m1.end( );

   // Count the number of elements in a map
   map <int, int>::difference_type  df_count = 1;
   m1_Iter = m1.begin( );
   while ( m1_Iter != m1_eIter)
   {
      df_count++;
      m1_Iter++;
   }

   cout << "The number of elements in the map m1 is: "
        << df_count << "." << endl;
}

The number of elements in the map m1 is: 4.

`emplace`

Insère un élément construit sur place (sans opération de copie ni de déplacement) dans une classe map.

template <class... Args>
pair<iterator, bool>
emplace(
    Args&&... args);

Paramètres

args
Arguments transférés pour construire un élément à insérer dans la carte, sauf s’il contient déjà un élément dont la valeur est ordonnée de manière équivalente.

Valeur de retour

Dont pair le composant est true si une insertion a été effectuée et false si la carte contenait déjà un élément de valeur équivalente dans l’ordrebool. Le composant itérateur de la paire de valeurs de retour pointe sur l'élément nouvellement inséré si le composant bool a la valeur true ou sur l'élément existant si le composant bool a la valeur false.

Pour accéder au composant itérateur d’un pair pr, utilisez pr.first; pour la déréférer, utilisez *pr.first. Pour accéder au composant bool, utilisez pr.second. Pour obtenir un exemple, voir l'exemple de code plus loin dans cet article.

Notes

Aucun itérateur ou référence n’est invalidé par cette fonction.

Pendant l’emplacement, si une exception est levée, l’état du conteneur n’est pas modifié.

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.

Exemple

// map_emplace.cpp
// compile with: /EHsc
#include <map>
#include <string>
#include <iostream>

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: ";

    for (const auto& p : m) {
        cout << "(" << p.first << ", " << p.second << ") ";
    }

    cout << endl;
}

int main()
{
    map<int, string> m1;

    auto ret = m1.emplace(10, "ten");

    if (!ret.second){
        auto pr = *ret.first;
        cout << "Emplace failed, element with key 10 already exists."
            << endl << "  The existing element is (" << pr.first << ", " << pr.second << ")"
            << endl;
        cout << "map not modified" << endl;
    }
    else{
        cout << "map modified, now contains ";
        print(m1);
    }
    cout << endl;

    ret = m1.emplace(10, "one zero");

    if (!ret.second){
        auto pr = *ret.first;
        cout << "Emplace failed, element with key 10 already exists."
            << endl << "  The existing element is (" << pr.first << ", " << pr.second << ")"
            << endl;
    }
    else{
        cout << "map modified, now contains ";
        print(m1);
    }
    cout << endl;
}

`emplace_hint`

Insère un élément construit sur place (aucune opération de copie ni de déplacement n’est effectuée) avec un indicateur de positionnement.

template <class... Args>
iterator emplace_hint(
    const_iterator where,
    Args&&... args);

Paramètres

args
Arguments transférés pour construire un élément à insérer dans la carte, sauf si le mappage contient déjà cet élément ou, plus généralement, sauf s’il contient déjà un élément dont la clé est ordonnée de manière équivalente.

where
Emplacement où commencer à rechercher le point d'insertion correct. (Si ce point précède immédiatement où, l’insertion peut se produire dans le temps constant amorti au lieu de l’heure logarithmique.)

Valeur de retour

Itérateur vers l’élément qui vient d’être inséré.

Si l’insertion a échoué car l’élément existe déjà, retourne un itérateur vers l’élément existant avec sa clé.

Notes

Aucun itérateur ou référence n’est invalidé par cette fonction.

Pendant l’emplacement, si une exception est levée, l’état du conteneur n’est pas modifié.

Exemple

// map_emplace.cpp
// compile with: /EHsc
#include <map>
#include <string>
#include <iostream>

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: " << endl;

    for (const auto& p : m) {
        cout << "(" << p.first <<  "," << p.second << ") ";
    }

    cout << endl;
}

int main()
{
    map<string, string> m1;

    // Emplace some test data
    m1.emplace("Anna", "Accounting");
    m1.emplace("Bob", "Accounting");
    m1.emplace("Carmine", "Engineering");

    cout << "map starting data: ";
    print(m1);
    cout << endl;

    // Emplace with hint
    // m1.end() should be the "next" element after this emplacement
    m1.emplace_hint(m1.end(), "Doug", "Engineering");

    cout << "map modified, now contains ";
    print(m1);
    cout << endl;
}

`empty`

Teste si une classe map est vide.

bool empty() const;

Valeur de retour

true si la carte est vide ; false si la carte n’est pas vide.

Exemple

// map_empty.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1, m2;

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

   if ( m1.empty( ) )
      cout << "The map m1 is empty." << endl;
   else
      cout << "The map m1 is not empty." << endl;

   if ( m2.empty( ) )
      cout << "The map m2 is empty." << endl;
   else
      cout << "The map m2 is not empty." << endl;
}

The map m1 is not empty.
The map m2 is empty.

`end`

Retourne l'itérateur past-the-end.

const_iterator end() const;

iterator end();

Valeur de retour

Itérateur de type past-the-end. Si la classe map est vide, map::end() == map::begin().

Notes

end est utilisé pour tester si un itérateur a réussi la fin de sa carte.

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

Pour obtenir un exemple de code, consultez map::find.

`equal_range`

Retourne une paire d’itérateurs qui représentent la lower_bound clé et la upper_bound 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 de la classe map dans laquelle la recherche est effectuée.

Valeur de retour

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

Exemple

// map_equal_range.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   typedef map <int, int, less<int> > IntMap;
   IntMap m1;
   map <int, int> :: const_iterator m1_RcIter;
   typedef pair <int, int> Int_Pair;

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

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

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

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

   // Compare the upper_bound called directly
   m1_RcIter = m1.upper_bound( 2 );

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

   p2 = m1.equal_range( 4 );

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

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

`erase`

Supprime des positions spécifiées un élément ou une plage d’éléments compris dans une classe map, ou supprime les éléments qui correspondent à une clé spécifiée.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Paramètres

Where
Position de l’élément à supprimer.

First
Position du premier élément à supprimer.

Last
Position juste après le dernier élément à supprimer.

Key
Valeur de clé des éléments à supprimer.

Valeur de retour

Pour les deux premières fonctions membres, itérateur bidirectionnel qui désigne le premier élément restant au-delà de tous les éléments supprimés, ou élément situé à la fin de l’objet map si 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 de la classe map.

Exemple

// map_erase.cpp
// compile with: /EHsc
#include <map>
#include <string>
#include <iostream>
#include <iterator> // next() and prev() helper functions
#include <utility>  // make_pair()

using namespace std;

using mymap = map<int, string>;

void printmap(const mymap& m) {
    for (const auto& elem : m) {
        cout << " [" << elem.first << ", " << elem.second << "]";
    }
    cout << endl << "size() == " << m.size() << endl << endl;
}

int main()
{
    mymap m1;

    // Fill in some data to test with, one at a time
    m1.insert(make_pair(1, "A"));
    m1.insert(make_pair(2, "B"));
    m1.insert(make_pair(3, "C"));
    m1.insert(make_pair(4, "D"));
    m1.insert(make_pair(5, "E"));

    cout << "Starting data of map m1 is:" << endl;
    printmap(m1);
    // The 1st member function removes an element at a given position
    m1.erase(next(m1.begin()));
    cout << "After the 2nd element is deleted, the map m1 is:" << endl;
    printmap(m1);

    // Fill in some data to test with, one at a time, using an initializer list
    mymap m2
    {
        { 10, "Bob" },
        { 11, "Rob" },
        { 12, "Robert" },
        { 13, "Bert" },
        { 14, "Bobby" }
    };

    cout << "Starting data of map m2 is:" << endl;
    printmap(m2);
    // The 2nd member function removes elements
    // in the range [First, Last)
    m2.erase(next(m2.begin()), prev(m2.end()));
    cout << "After the middle elements are deleted, the map m2 is:" << endl;
    printmap(m2);

    mymap m3;

    // Fill in some data to test with, one at a time, using emplace
    m3.emplace(1, "red");
    m3.emplace(2, "yellow");
    m3.emplace(3, "blue");
    m3.emplace(4, "green");
    m3.emplace(5, "orange");
    m3.emplace(6, "purple");
    m3.emplace(7, "pink");

    cout << "Starting data of map m3 is:" << endl;
    printmap(m3);
    // The 3rd member function removes elements with a given Key
    mymap::size_type count = m3.erase(2);
    // The 3rd member function also returns the number of elements removed
    cout << "The number of elements removed from m3 is: " << count << "." << endl;
    cout << "After the element with a key of 2 is deleted, the map m3 is:" << endl;
    printmap(m3);
}

`find`

Retourne un itérateur qui fait référence à l'emplacement d'un élément dans un mappage ayant une clé équivalente à la clé spécifiée.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Paramètres

key
Valeur de clé qui doit correspondre à la clé de tri d'un élément du mappage dans lequel la recherche est effectuée.

Valeur de retour

Itérateur qui fait référence à l’emplacement d’un élément avec une clé spécifiée ou à l’emplacement qui réussit le dernier élément dans le map (map::end()) si aucune correspondance n’est trouvée pour la clé.

Notes

La fonction membre retourne un itérateur qui fait référence à un élément dans la 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 map est affectée à un const_iterator, l’objet map ne peut pas être modifié. Si la valeur de retour d’un find iteratorobjet map peut être modifiée

Exemple

// compile with: /EHsc /W4 /MTd
#include <map>
#include <iostream>
#include <vector>
#include <string>
#include <utility>  // make_pair()

using namespace std;

template <typename A, typename B> void print_elem(const pair<A, B>& p) {
    cout << "(" << p.first << ", " << p.second << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

template <typename C, class T> void findit(const C& c, T val) {
    cout << "Trying find() on value " << val << endl;
    auto result = c.find(val);
    if (result != c.end()) {
        cout << "Element found: "; print_elem(*result); cout << endl;
    } else {
        cout << "Element not found." << endl;
    }
}

int main()
{
    map<int, string> m1({ { 40, "Zr" }, { 45, "Rh" } });
    cout << "The starting map m1 is (key, value):" << endl;
    print_collection(m1);

    vector<pair<int, string>> v;
    v.push_back(make_pair(43, "Tc"));
    v.push_back(make_pair(41, "Nb"));
    v.push_back(make_pair(46, "Pd"));
    v.push_back(make_pair(42, "Mo"));
    v.push_back(make_pair(44, "Ru"));
    v.push_back(make_pair(44, "Ru")); // attempt a duplicate

    cout << "Inserting the following vector data into m1:" << endl;
    print_collection(v);

    m1.insert(v.begin(), v.end());

    cout << "The modified map m1 is (key, value):" << endl;
    print_collection(m1);
    cout << endl;
    findit(m1, 45);
    findit(m1, 6);
}

`get_allocator`

Retourne une copie de l’objet allocateur utilisé pour construire la classe map.

allocator_type get_allocator() const;

Valeur de retour

Allocateur utilisé par la classe map.

Notes

Les allocateurs de la classe map 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

// map_get_allocator.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int>::allocator_type m1_Alloc;
   map <int, int>::allocator_type m2_Alloc;
   map <int, double>::allocator_type m3_Alloc;
   map <int, int>::allocator_type m4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   map <int, int> m1;
   map <int, int, allocator<int> > m2;
   map <int, double, allocator<double> > m3;

   m1_Alloc = m1.get_allocator( );
   m2_Alloc = m2.get_allocator( );
   m3_Alloc = m3.get_allocator( );

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

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

   // The following line creates a map m4
   // with the allocator of map m1.
   map <int, int> m4( less<int>( ), m1_Alloc );

   m4_Alloc = m4.get_allocator( );

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

`insert`

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

// (1) single element
pair<iterator, bool> insert(
    const value_type& Val);

// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
    ValTy&& Val);

// (3) single element with hint
iterator insert(
    const_iterator Where,
    const value_type& Val);

// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

// (5) range
template <class InputIterator>
void insert(
    InputIterator First,
    InputIterator Last);

// (6) initializer list
void insert(
    initializer_list<value_type>
IList);

Paramètres

Val
Valeur d’un élément à insérer dans la carte, sauf s’il contient déjà un élément dont la clé est ordonnée de manière équivalente.

Where
Emplacement où commencer à rechercher le point d'insertion correct. (Si ce point précède immédiatement Where, l'insertion peut se produire dans le temps fixe amorti plutôt que dans le temps logarithmique.)

ValTy
Paramètre de modèle qui spécifie le type d’argument que la carte peut utiliser pour construire un élément de value_type, et des forwards parfaits Val en tant qu’argument.

First
Position du premier élément à copier.

Last
Position juste au-delà du dernier élément à copier.

InputIterator
Argument de fonction de modèle qui répond aux exigences d’un itérateur d’entrée qui pointe vers des éléments d’un type qui peuvent être utilisés pour construire value_type des objets.

IList
initializer_list À partir duquel copier les éléments.

Valeur de retour

Les fonctions membres à un élément, (1) et (2), retournent un pair composant dont bool le composant est vrai si une insertion a été effectuée, et false si la carte contenait déjà un élément dont la clé avait une valeur équivalente dans l’ordre. Le composant itérateur de la paire de valeurs de retour pointe sur l'élément nouvellement inséré si le composant bool a la valeur true ou sur l'élément existant si le composant bool a la valeur false.

Les fonctions membres à un élément avec indicateur, (3) et (4), retournent un itérateur qui pointe sur la position où le nouvel élément a été inséré dans la classe map ou, si un élément avec une clé équivalente existe déjà, sur l'élément existant.

Notes

Aucun itérateur, pointeur ou référence n'est invalidé par cette fonction.

Pendant l’insertion d’un seul élément, si une exception est levée, l’état du conteneur n’est pas modifié. Durant l'insertion de plusieurs éléments, si une exception est levée, le conteneur reste dans un état non spécifié mais valide.

Pour accéder au composant itérateur d’un pair pr élément retourné par les fonctions membres à élément unique, utilisez pr.first; pour déréférer l’itérateur au sein de la paire retournée, utilisez *pr.first, ce qui vous donne un élément. Pour accéder au composant bool, utilisez pr.second. Pour obtenir un exemple, voir l'exemple de code plus loin dans cet article.

Un value_type conteneur est un typedef qui appartient au conteneur, et pour map, map<K, V>::value_type est pair<const K, V>. La valeur d'un élément est une paire ordonnée dans laquelle le premier composant est égal à la valeur de clé et le second composant est égal à la valeur de données de l'élément.

La fonction membre de plage (5) insère la séquence de valeurs d'éléments dans une classe map qui correspond à chaque élément traité par un itérateur dans la plage [First, Last) ; ainsi, Last n'est pas inséré. La fonction membre de conteneur end() fait référence à la position qui suit le dernier élément du conteneur. Par exemple, l'instruction m.insert(v.begin(), v.end()); tente d'insérer tous les éléments de v dans m. Seuls les éléments qui ont des valeurs uniques dans la plage sont insérés. Les doublons sont ignorés. Pour savoir quels éléments sont rejetés, utilisez les versions à un élément de insert.

La fonction membre de liste d’initialiseurs (6) utilise un initializer_list pour copier des éléments dans la carte.

Pour l’insertion d’un élément construit en place, autrement dit, aucune opération de copie ou de déplacement n’est effectuée, consultez map::emplace et map::emplace_hint.

Exemple

// map_insert.cpp
// compile with: /EHsc
#include <map>
#include <iostream>
#include <string>
#include <vector>
#include <utility>  // make_pair()

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: ";

    for (const auto& p : m) {
        cout << "(" << p.first << ", " << p.second << ") ";
    }

    cout << endl;
}

int main()
{
    // insert single values
    map<int, int> m1;
    // call insert(const value_type&) version
    m1.insert({ 1, 10 });
    // call insert(ValTy&&) version
    m1.insert(make_pair(2, 20));

    cout << "The original key and mapped values of m1 are:" << endl;
    print(m1);

    // intentionally attempt a duplicate, single element
    auto ret = m1.insert(make_pair(1, 111));
    if (!ret.second){
        auto pr = *ret.first;
        cout << "Insert failed, element with key value 1 already exists."
            << endl << "  The existing element is (" << pr.first << ", " << pr.second << ")"
            << endl;
    }
    else{
        cout << "The modified key and mapped values of m1 are:" << endl;
        print(m1);
    }
    cout << endl;

    // single element, with hint
    m1.insert(m1.end(), make_pair(3, 30));
    cout << "The modified key and mapped values of m1 are:" << endl;
    print(m1);
    cout << endl;

    // The templatized version inserting a jumbled range
    map<int, int> m2;
    vector<pair<int, int>> v;
    v.push_back(make_pair(43, 294));
    v.push_back(make_pair(41, 262));
    v.push_back(make_pair(45, 330));
    v.push_back(make_pair(42, 277));
    v.push_back(make_pair(44, 311));

    cout << "Inserting the following vector data into m2:" << endl;
    print(v);

    m2.insert(v.begin(), v.end());

    cout << "The modified key and mapped values of m2 are:" << endl;
    print(m2);
    cout << endl;

    // The templatized versions move-constructing elements
    map<int, string>  m3;
    pair<int, string> ip1(475, "blue"), ip2(510, "green");

    // single element
    m3.insert(move(ip1));
    cout << "After the first move insertion, m3 contains:" << endl;
    print(m3);

    // single element with hint
    m3.insert(m3.end(), move(ip2));
    cout << "After the second move insertion, m3 contains:" << endl;
    print(m3);
    cout << endl;

    map<int, int> m4;
    // Insert the elements from an initializer_list
    m4.insert({ { 4, 44 }, { 2, 22 }, { 3, 33 }, { 1, 11 }, { 5, 55 } });
    cout << "After initializer_list insertion, m4 contains:" << endl;
    print(m4);
    cout << endl;
}

`iterator`

Type qui fournit un itérateur bidirectionnel capable de lire ou de modifier tout élément d’une classe map.

typedef implementation-defined iterator;

Notes

Itérateur défini par le mappage pointe 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 le datum mappé détenu par l’élément.

Pour déréférencer un itérateur Iter pointant vers un élément d’une carte, 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.

Exemple

Consultez l’exemple pour begin obtenir un exemple de déclaration et d’utilisation iterator.

`key_comp`

Récupère une copie de l’objet de comparaison utilisé pour trier les clés au sein d’une classe map.

key_compare key_comp() const;

Valeur de retour

Retourne l’objet de fonction utilisé par une classe map pour ordonner 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

// map_key_comp.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;

   map <int, int, less<int> > m1;
   map <int, int, less<int> >::key_compare kc1 = m1.key_comp( ) ;
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true, "
           << "where kc1 is the function object of m1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of m1."
           << endl;
   }

   map <int, int, greater<int> > m2;
   map <int, int, greater<int> >::key_compare kc2 = m2.key_comp( );
   bool result2 = kc2( 2, 3 ) ;
   if( result2 == true )
   {
      cout << "kc2( 2,3 ) returns value of true, "
           << "where kc2 is the function object of m2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of m2."
           << endl;
   }
}

kc1( 2,3 ) returns value of true, where kc1 is the function object of m1.
kc2( 2,3 ) returns value of false, where kc2 is the function object of m2.

`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 map.

typedef Traits key_compare;

Notes

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

Pour plus d’informations sur Traits, consultez la map rubrique Classe .

Exemple

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

`key_type`

Type qui décrit la clé de tri stockée dans chaque élément de la classe 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 map rubrique Classe .

Exemple

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

`lower_bound`

Retourne un itérateur pointant vers le premier élément d’une classe 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 de la classe map dans laquelle la recherche est effectuée.

Valeur de retour

Ou iterator qui traite l’emplacement d’un élément dans une carte 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 map cas où aucune correspondance n’est trouvée pour la const_iterator clé.

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

Exemple

// map_lower_bound.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;
   map <int, int> :: const_iterator m1_AcIter, m1_RcIter;
   typedef pair <int, int> Int_Pair;

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

   m1_RcIter = m1.lower_bound( 2 );
   cout << "The first element of map m1 with a key of 2 is: "
        << m1_RcIter -> second << "." << endl;

   // If no match is found for this key, end( ) is returned
   m1_RcIter = m1. lower_bound ( 4 );

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

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

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

`map`

Construit une classe map vide ou une copie de l’ensemble, ou d’une partie d’une autre classe map.

map();

explicit map(
    const Traits& Comp);

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

map(
    const map& Right);

map(
    map&& Right);

map(
    initializer_list<value_type> IList);

map(
    initializer_list<value_type> IList,
    const Traits& Comp);

map(
    initializer_list<value_type> IList,
    const Traits& Comp,
    const Allocator& Allocator);

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

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

template <class InputIterator>
map(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp,
    const Allocator& Al);

Paramètres

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

Comp
Fonction de comparaison de type const Traits utilisée pour ordonner les éléments dans le map (par défaut, hash_compare).

Right
Mappage dont l’ensemble construit 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 à partir de laquelle les éléments doivent être copiés.

Notes

Tous les constructeurs stockent un type d’objet allocator qui gère le stockage de mémoire pour la carte et qui 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 classe map.

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

Les trois premiers constructeurs spécifient une carte initiale vide, la deuxième spécifiant le type de fonction de comparaison (Comp) à utiliser pour établir l’ordre des éléments et le troisième spécifiant 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 de la classe map Right.

Le cinquième constructeur spécifie une copie de la classe map en déplaçant Right.

Les constructeurs 6e, 7e et 8e utilisent un initializer_list constructeur à partir duquel copier les membres.

Les trois constructeurs suivants copient la plage [First, Last) d’une classe map avec un caractère explicite croissant en ce qui concerne la spécification du type de fonction de comparaison de la classe Traits et de l’allocateur.

Exemple

// map_map.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main()
{
    using namespace std;
    typedef pair <int, int> Int_Pair;
    map <int, int>::iterator m1_Iter, m3_Iter, m4_Iter, m5_Iter, m6_Iter, m7_Iter;
    map <int, int, less<int> >::iterator m2_Iter;

    // Create an empty map m0 of key type integer
    map <int, int> m0;

    // Create an empty map m1 with the key comparison
    // function of less than, then insert 4 elements
    map <int, int, less<int> > m1;
    m1.insert(Int_Pair(1, 10));
    m1.insert(Int_Pair(2, 20));
    m1.insert(Int_Pair(3, 30));
    m1.insert(Int_Pair(4, 40));

    // Create an empty map m2 with the key comparison
    // function of greater than, then insert 2 elements
    map <int, int, less<int> > m2;
    m2.insert(Int_Pair(1, 10));
    m2.insert(Int_Pair(2, 20));

    // Create a map m3 with the
    // allocator of map m1
    map <int, int>::allocator_type m1_Alloc;
    m1_Alloc = m1.get_allocator();
    map <int, int> m3(less<int>(), m1_Alloc);
    m3.insert(Int_Pair(3, 30));

    // Create a copy, map m4, of map m1
    map <int, int> m4(m1);

    // Create a map m5 by copying the range m1[ first,  last)
    map <int, int>::const_iterator m1_bcIter, m1_ecIter;
    m1_bcIter = m1.begin();
    m1_ecIter = m1.begin();
    m1_ecIter++;
    m1_ecIter++;
    map <int, int> m5(m1_bcIter, m1_ecIter);

    // Create a map m6 by copying the range m4[ first,  last)
    // and with the allocator of map m2
    map <int, int>::allocator_type m2_Alloc;
    m2_Alloc = m2.get_allocator();
    map <int, int> m6(m4.begin(), ++m4.begin(), less<int>(), m2_Alloc);

    cout << "m1 =";
    for (auto i : m1)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m2 =";
    for(auto i : m2)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m3 =";
    for (auto i : m3)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m4 =";
    for (auto i : m4)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m5 =";
    for (auto i : m5)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m6 =";
    for (auto i : m6)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a map m7 by moving m5
    cout << "m7 =";
    map<int, int> m7(move(m5));
    for (auto i : m7)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a map m8 by copying in an initializer_list
    map<int, int> m8{ { { 1, 1 }, { 2, 2 }, { 3, 3 }, { 4, 4 } } };
    cout << "m8: = ";
    for (auto i : m8)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a map m9 with an initializer_list and a comparator
    map<int, int> m9({ { 5, 5 }, { 6, 6 }, { 7, 7 }, { 8, 8 } }, less<int>());
    cout << "m9: = ";
    for (auto i : m9)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a map m10 with an initializer_list, a comparator, and an allocator
    map<int, int> m10({ { 9, 9 }, { 10, 10 }, { 11, 11 }, { 12, 12 } }, less<int>(), m9.get_allocator());
    cout << "m10: = ";
    for (auto i : m10)
        cout << i.first << " " << i.second << ", ";
    cout << endl;
}

`mapped_type`

Type qui représente le type de données stocké dans une classe map.

typedef Type mapped_type;

Notes

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

Pour plus d’informations sur Type, consultez la map rubrique Classe .

Exemple

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

`max_size`

Retourne la longueur maximale de la classe map.

size_type max_size() const;

Valeur de retour

Longueur maximale autorisée de la classe map.

Exemple

// map_max_size.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;
   map <int, int> :: size_type i;

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

`operator[]`

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

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

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

Paramètres

key
Valeur 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.

operator[] peut être utilisé pour insérer des éléments dans une classe map m en utilisant 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 l'insertion va modifier un élément existant ou en créer 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

// map_op_insert.cpp
// compile with: /EHsc
#include <map>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   typedef pair <const int, int> cInt2Int;
   map <int, int> m1;
   map <int, int> :: iterator pIter;

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

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

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

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

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

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

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

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

// insert by moving key
    map<string, int> c2;
    string str("abc");
    cout << "c2[move(str)] == " << c2[move(str)] << endl;
    cout << "c2["abc"] == " << c2["abc"] << endl;

    return (0);
}

The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 30.
The keys of the mapped elements are now: 1 2 3 5.
The values of the mapped elements are now: 10 40 30 0.
c2[move(str)] == 0
c2["abc"] == 1

`operator=`

Remplace les éléments d'une classe map par une copie d'une autre classe map.

map& operator=(const map& right);
map& operator=(map&& right);

Paramètres

right
En map cours de copie dans le map.

Notes

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

Exemple

// map_operator_as.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
   {
   using namespace std;
   map<int, int> v1, v2, v3;
   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;
   }

`pointer`

Type qui fournit un pointeur vers un élément d’une classe map.

typedef typename 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 objet map.

rbegin

Retourne un itérateur qui traite le premier élément d’une classe map inversée.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valeur de retour

Itérateur bidirectionnel inversé qui traite le premier élément d’une classe map inversée ou qui traite ce qui était le dernier élément de la classe map non inversée.

Notes

rbegin est utilisé avec une carte inversée, tout comme begin avec une carte.

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

Vous pouvez utiliser rbegin pour itérer une classe map vers l’arrière.

Exemple

// map_rbegin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;

   map <int, int> :: iterator m1_Iter;
   map <int, int> :: reverse_iterator m1_rIter;
   map <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_rIter = m1.rbegin( );
   cout << "The first element of the reversed map m1 is "
        << m1_rIter -> first << "." << endl;

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

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

   // A map element can be erased by dereferencing to its key
   m1_rIter = m1.rbegin( );
   m1.erase ( m1_rIter -> first );

   m1_rIter = m1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed map is "
        << m1_rIter -> first << "." << endl;
}

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

`reference`

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

typedef typename allocator_type::reference reference;

Exemple

// map_reference.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;
   typedef pair <int, int> Int_Pair;

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

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

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

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

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

   cout << "The data value of first element in the 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 map is 1.
The data value of first element in the map is 10.
The modified data value of first element is 15.

`rend`

Retourne un itérateur qui traite l’emplacement suivant le dernier élément d’une classe map inversée.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valeur de retour

Itérateur bidirectionnel inversé qui traite l’emplacement qui suit le dernier élément d’une classe map inversée (emplacement qui précédait le premier élément de la classe map non inversée).

Notes

rend est utilisé avec une carte inversée, tout comme end avec une carte.

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

Vous pouvez utiliser rend pour déterminer si un itérateur inversé a atteint la fin de sa classe map.

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

Exemple

// map_rend.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;

   map <int, int> :: iterator m1_Iter;
   map <int, int> :: reverse_iterator m1_rIter;
   map <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_rIter = m1.rend( );
   m1_rIter--;
   cout << "The last element of the reversed map m1 is "
        << m1_rIter -> first << "." << endl;

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

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

   // A map element can be erased by dereferencing to its key
   m1_rIter = --m1.rend( );
   m1.erase ( m1_rIter -> first );

   m1_rIter = m1.rend( );
   m1_rIter--;
   cout << "After the erasure, the last element "
        << "in the reversed map is "
        << m1_rIter -> first << "." << endl;
}

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

`reverse_iterator`

Type qui fournit un itérateur bidirectionnel capable de lire ou de modifier tout élément d’une classe map inversée.

typedef std::reverse_iterator<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 la carte en sens inverse.

Défini par le reverse_iterator mappage pointe 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 reverse_iterator rIter pointant vers un élément d’une carte, utilisez l’opérateur -> .

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

Exemple

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

`size`

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

size_type size() const;

Valeur de retour

Longueur actuelle du map.

Exemple

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

// map_size.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main()
{
    using namespace std;
    map<int, int> m1, m2;
    map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

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

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

The map length is 1.
The map length is now 2.

`size_type`

Type entier non signé qui peut représenter le nombre d’éléments d’une classe map.

typedef typename allocator_type::size_type size_type;

Exemple

Consultez l’exemple pour size obtenir un exemple de déclaration et d’utilisation size_type.

swap

Échange les éléments de deux classes map.

void swap(
    map<Key, Type, Traits, Allocator>& right);

Paramètres

right
Argument map qui fournit les éléments à échanger avec la classe map cible.

Notes

La fonction membre n’invalide aucun pointeur, itérateur ou référence qui désigne des éléments dans les deux classes map dont les éléments sont échangés.

Exemple

// map_swap.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1, m2, m3;
   map <int, int>::iterator m1_Iter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );
   m2.insert ( Int_Pair ( 10, 100 ) );
   m2.insert ( Int_Pair ( 20, 200 ) );
   m3.insert ( Int_Pair ( 30, 300 ) );

   cout << "The original map m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;

   // This is the member function version of swap
   //m2 is said to be the argument map; m1 the target map
   m1.swap( m2 );

   cout << "After swapping with m2, map m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( m1, m3 );

   cout << "After swapping with m3, map m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;
}

The original map m1 is: 10 20 30.
After swapping with m2, map m1 is: 100 200.
After swapping with m3, map m1 is: 300.

`upper_bound`

Retourne un itérateur pointant vers le premier élément d’une classe map qui a une valeur de clé 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 de la classe map dans laquelle la recherche est effectuée.

Valeur de retour

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

Si la valeur de retour est affectée à un const_iteratorobjet map, vous ne pouvez pas modifier l’objet map. Si la valeur de retour est affectée à un iterator, l’objet map peut être modifié.

Exemple

// map_upper_bound.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;
   map <int, int> :: const_iterator m1_AcIter, m1_RcIter;
   typedef pair <int, int> Int_Pair;

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

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

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

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

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

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

`value_comp`

La fonction membre retourne un objet de fonction qui détermine l’ordre des éléments d’une classe map en comparant leurs valeurs de clés.

value_compare value_comp() const;

Valeur de retour

Retourne l’objet de fonction de comparaison utilisé par une classe map pour ordonner ses éléments.

Notes

Pour une carte m, si deux éléments e1(k1, d1) et e2(k2, d2) sont des objets de type value_type, où k1 et k1 sont leurs clés de type key_type et d1 et d2 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

// map_value_comp.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;

   map <int, int, less<int> > m1;
   map <int, int, less<int> >::value_compare vc1 = m1.value_comp( );
   pair< map<int,int>::iterator, bool > pr1, pr2;

   pr1= m1.insert ( map <int, int> :: value_type ( 1, 10 ) );
   pr2= m1.insert ( 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;
   }
}

The element ( 1,10 ) precedes the element ( 2,5 ).
The element ( 2,5 ) does not precede the element ( 1,10 ).

`value_type`

Type de l’objet stocké comme élément dans une classe map.

typedef pair<const Key, Type> value_type;

Exemple

// map_value_type.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

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

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

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

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

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

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

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

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

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

Voir aussi

conteneurs
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 map

Syntaxe

Paramètres

Notes

Membres

Constructeurs

Typedefs

Fonctions Membre

Opérateurs

allocator_type

Exemple

at

Paramètres

Valeur de retour

Notes

Exemple

begin

Valeur de retour

Exemple

cbegin

Valeur de retour

Notes

cend

Valeur de retour

Notes

clear

Exemple

const_iterator

Notes

Exemple

const_pointer

Notes

const_reference

Exemple

const_reverse_iterator

Notes

Exemple

count

Paramètres

Valeur de retour

Notes

Exemple

contains

Paramètres

Valeur de retour

Notes

Exemple

crbegin

Valeur de retour

Notes

Exemple

crend

Valeur de retour

Notes

Exemple

difference_type

Notes

Exemple

emplace

Paramètres

Valeur de retour

Notes

Exemple

emplace_hint

Paramètres

Valeur de retour

Notes

Exemple

empty

Valeur de retour

Exemple

end

Valeur de retour

Notes

equal_range

Paramètres

Valeur de retour

Exemple

erase

La classe `map`

`allocator_type`

`at`

`begin`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`count`

`contains`

`crbegin`

`crend`

`difference_type`

`emplace`

`emplace_hint`

`empty`

`end`

`equal_range`

`erase`

`find`

`get_allocator`

`insert`

`iterator`

`key_comp`

`key_compare`

`key_type`

`lower_bound`

`map`

`mapped_type`

`max_size`

`operator[]`

`operator=`

`pointer`

`reference`

`rend`

`reverse_iterator`

`size`