La classe map
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 cbegin
la 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 map
inversé 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é.
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: " << 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
iterator
objet 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
iterator
objet 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_iterator
objet 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++
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : pendant toute l’année 2024, nous allons éliminer progressivement Problèmes GitHub comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, voir :Soumettre et afficher des commentaires pour