Classe `map`

Articolo
06/16/2023

Utilizzato per l'archiviazione e il recupero di dati da una raccolta in cui ogni elemento è costituito da una coppia che contiene sia un valore dati che una chiave di ordinamento. Il valore della chiave è univoco e viene utilizzato per l'ordinamento automatico dei dati.

Il valore di un elemento di una mappa può essere modificato direttamente. Il valore della chiave è una costante e non può essere modificato. Al contrario, i valori delle chiavi associati a elementi precedenti devono essere eliminati e i valori delle nuove chiavi devono essere inseriti per i nuovi elementi.

Sintassi

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

Parametri

Key
Tipo di dati chiave da archiviare in map.

Type
Tipo di dati degli elementi da archiviare in map.

Traits
Tipo che fornisce un oggetto funzione in grado di confrontare due valori di elemento come chiavi di ordinamento per determinare il relativo ordine nell'oggetto map. Questo argomento è facoltativo e il predicato binario less<Key> rappresenta il valore predefinito.

In C++14 è possibile abilitare la ricerca eterogenea specificando il std::less<> predicato senza parametri di tipo. Per altre informazioni, vedere Ricerca eterogenea nei contenitori associativi .

Allocator
Tipo che rappresenta l'oggetto allocatore archiviato che incapsula i dettagli relativi all'allocazione della mappa e alla deallocazione della memoria. Questo argomento è facoltativo e il valore predefinito è allocator<pair<const Key, Type> >.

Osservazioni:

La classe map della libreria standard C++ è:

Un contenitore di dimensioni variabili in grado di recuperare in modo efficiente i valori degli elementi in base ai valori delle chiavi associate.
Reversibile, in quanto fornisce iteratori bidirezionali per accedere ai relativi elementi.
Ordinato, perché i relativi elementi vengono ordinati in base ai valori delle chiavi secondo una funzione di confronto specificata.
Univoco. perché ogni elemento deve disporre di una chiave univoca.
Un contenitore associativo di coppie, in quanto i valori dei dati degli elementi sono diversi dai valori delle relative chiavi.
Un modello di classe, perché la funzionalità fornita è generica e indipendente dall'elemento o dal tipo di chiave. I tipi di dati utilizzati per gli elementi e le chiavi vengono specificati come parametri nella classe modello insieme alla funzione di confronto e all'allocatore.

L'iteratore fornito dalla classe map è un iteratore bidirezionale, ma le insert funzioni membro della classe e map hanno versioni che accettano come parametri di modello un iteratore di input più debole, i cui requisiti di funzionalità sono inferiori a quelli garantiti dalla classe di iteratori bidirezionali. I diversi concetti di iteratore sono correlati dai perfezionamenti delle rispettive funzionalità. Ogni concetto di iteratore dispone di un proprio set di requisiti e gli algoritmi utilizzati con tali concetti devono essere limitati da tali requisiti. Un iteratore di input può essere dereferenziato per fare riferimento a un determinato oggetto, nonché incrementato all'iteratore successivo della sequenza.

È consigliabile basare la scelta del tipo di contenitore sul tipo di ricerca e inserimento richiesti dall'applicazione. I contenitori associativi sono ottimizzati per le operazioni di ricerca, inserimento e rimozione. Le funzioni membro che supportano in modo esplicito queste operazioni le eseguono in un momento peggiore che è proporzionale al logaritmo del numero di elementi nel contenitore. L'inserimento di elementi non invalida gli iteratori e la rimozione di tali elementi invalida solo gli iteratori che avevano puntato in modo specifico agli elementi rimossi.

È consigliabile scegliere come contenitore associativo la mappa quando le condizioni che consentono di associare i valori alle chiavi vengono soddisfatte dall'applicazione. Un modello relativo a questo tipo di struttura è costituito da un elenco ordinato di parole chiave univoche a cui sono associati valori di stringa contenenti definizioni. Se una parola ha più di una definizione corretta, in modo che la chiave non sia univoca, un multimap sarà il contenitore preferito. Se viene archiviato solo un elenco di parole, il set sarà il contenitore appropriato. Se sono consentite più occorrenze delle parole, il multiset rappresenterà la scelta appropriata.

La mappa ordina gli elementi che controlla chiamando un oggetto funzione archiviato di tipo key_compare. Questo oggetto archiviato è una funzione di confronto a cui si accede chiamando il key_comp metodo . In generale, due elementi specificati vengono confrontati per determinare se uno è minore dell'altro o se sono equivalenti. Una volta che tutti gli elementi sono stati confrontati, viene creata una sequenza ordinata di elementi non equivalenti.

Nota

La funzione di confronto è un predicato binario che provoca un ordinamento di tipo "strict weak" nel senso matematico standard. Un predicato binario f(x,y) è un oggetto funzione che dispone di due oggetti argomento x e y e di un valore restituito true o false. Un ordinamento imposto a un set è un ordinamento debole rigoroso se il predicato binario è irreflessivo, antisymmetrico e transitivo e se l'equivalenza è transitiva, dove due oggetti x e y vengono definiti come equivalenti quando entrambi f(x,y) e f(y,x) sono false. Se la condizione di uguaglianza più forte tra le chiavi sostituisce quella di equivalenza, l'ordinamento diventa totale (nel senso che tutti gli elementi vengono ordinati l'uno rispetto all'altro) e le chiavi accoppiate saranno indistinguibili l'una dall'altra.

In C++14 è possibile abilitare la ricerca eterogenea specificando il std::less<> predicato o std::greater<> senza parametri di tipo. Per altre informazioni, vedere Ricerca eterogenea nei contenitori associativi .

Membri

Costruttori

Nome	Descrizione
`map`	Costruisce una lista di dimensioni specifiche con elementi di un valore specifico, con un `allocator` specifico o come copia di un'altra mappa.

Typedef

Nome	Descrizione
`allocator_type`	typedef per la classe `allocator` dell'oggetto mappa.
`const_iterator`	typedef per un iteratore bidirezionale in grado di leggere un elemento `const` nel `map`.
`const_pointer`	typedef per un puntatore a un elemento `const` di una mappa.
`const_reference`	Typedef per un riferimento a un elemento archiviato in una `const` mappa per la lettura e l'esecuzione di `const` operazioni.
`const_reverse_iterator`	Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento `const` nel `map`.
`difference_type`	typedef Signed Integer per il numero di elementi di una mappa in un intervallo compreso tra gli elementi a cui puntano gli iteratori.
`iterator`	typedef per un iteratore bidirezionale in grado di leggere o di modificare qualsiasi elemento di una mappa.
`key_compare`	typedef per un oggetto funzione in grado di confrontare due chiavi di ordinamento per determinare l'ordine relativo di due elementi nel `map`.
`key_type`	typedef per la chiave di ordinamento archiviata in ogni elemento della mappa.
`mapped_type`	typedef per i dati archiviati in ogni elemento di una mappa.
`pointer`	typedef per un puntatore a un elemento `const` di una mappa.
`reference`	typedef per un riferimento a un elemento archiviato in una mappa.
`reverse_iterator`	typedef per un iteratore bidirezionale in grado di leggere o di modificare un elemento di una mappa invertita.
`size_type`	typedef Unsigned Integer per il numero di elementi di una mappa
`value_type`	typedef per il tipo di oggetto archiviato come elemento di una mappa.

Funzioni membro

Funzione membro	Descrizione
`at`	Trova un elemento con il valore della chiave specificato.
`begin`	Restituisce un iteratore che punta al primo elemento del `map`.
`cbegin`	Restituisce un iteratore const che punta al primo elemento dell'oggetto `map`.
`cend`	Restituisce un iteratore const successivo all'ultimo valore.
`clear`	Cancella tutti gli elementi di un `map`.
`contains`^C++20	Controllare se è presente un elemento con la chiave specificata in `map`.
`count`	Restituisce il numero di elementi di una mappa la cui chiave corrisponde alla chiave specificata in un parametro.
`crbegin`	Restituisce un iteratore const che punta al primo elemento di un oggetto invertito `map`.
`crend`	Restituisce un iteratore const che punta alla posizione dopo l'ultimo elemento di un oggetto `map`invertito.
`emplace`	Inserisce un elemento costruito sul posto nell'oggetto `map`.
`emplace_hint`	Inserisce un elemento costruito sul posto in `map`, con un hint di posizionamento.
`empty`	Restituisce `true` se un oggetto `map` è vuoto.
`end`	Restituisce l'iteratore successivo all'ultimo valore.
`equal_range`	Restituisce una coppia di iteratori. Il primo iteratore della coppia fa riferimento al primo elemento di un `map` con una chiave maggiore di una chiave specificata. Il secondo iteratore della coppia fa riferimento al primo elemento della `map` con una chiave uguale o maggiore della chiave specificata.
`erase`	Rimuove un elemento o un intervallo di elementi di una mappa dalle posizioni specificate.
`find`	Restituisce un iteratore che punta alla posizione di un elemento in un `map` oggetto con una chiave uguale a una chiave specificata.
`get_allocator`	Restituisce una copia dell'oggetto `allocator` utilizzato per costruire il `map`.
`insert`	Incolla un elemento o un intervallo di elementi nel `map` in una posizione specificata.
`key_comp`	Restituisce una copia dell'oggetto di confronto utilizzato per ordinare le chiavi in un oggetto `map`.
`lower_bound`	Restituisce un iteratore al primo elemento di un `map` oggetto con un valore di chiave uguale o maggiore di quello di una chiave specificata.
`max_size`	Restituisce la lunghezza massima del `map`.
`rbegin`	Restituisce un iteratore che punta al primo elemento di un `map` invertito.
`rend`	Restituisce un iteratore che punta alla posizione dopo l'ultimo elemento di un oggetto invertito `map`.
`size`	Restituisce il numero di elementi nel `map`.
`swap`	Scambia gli elementi di due oggetti map.
`upper_bound`	Restituisce un iteratore al primo elemento di un `map` oggetto con un valore di chiave maggiore di quello di una chiave specificata.
`value_comp`	Recupera una copia dell'oggetto di confronto utilizzato per ordinare i valori degli elementi di un `map`.

Operatori

Nome	Descrizione
`operator[]`	Inserisce un elemento in una mappa con un valore di chiave specificato.
`operator=`	Sostituisce gli elementi di una mappa con una copia di un'altra mappa.

`allocator_type`

Tipo che rappresenta la classe allocator per l'oggetto map.

typedef Allocator allocator_type;

Esempio

Vedere l'esempio per get_allocator un esempio che usa allocator_type.

`at`

Trova un elemento con un valore della chiave specificata.

Type& at(const Key& key);

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

Parametri

key
Valore di chiave da trovare.

Valore restituito

Riferimento al valore dei dati dell'elemento trovato.

Osservazioni:

Se il valore della chiave dell'argomento non viene trovato, la funzione genera un oggetto della classe out_of_range Class.

Esempio

// 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`

Restituisce un iteratore che punta al primo elemento del map.

const_iterator begin() const;

iterator begin();

Valore restituito

Iteratore bidirezionale che punta al primo elemento dell'oggetto map o alla posizione successiva a una mappa vuota.

Esempio

// 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`

Restituisce un iteratore const che punta alla posizione oltre l'ultimo elemento di un intervallo.

const_iterator cbegin() const;

Valore restituito

Iteratore bidirezionale const che punta al primo elemento dell'intervallo o alla posizione oltre la fine di un intervallo vuoto (per un intervallo vuoto, cbegin() == cend()).

Osservazioni:

Con il valore restituito di cbegin, gli elementi nell'intervallo non possono essere modificati.

È possibile usare questa funzione membro anziché la funzione membro begin() per garantire che il valore restituito sia const_iterator. In genere, viene usato insieme alla parola chiave di deduzione del auto tipo, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile di qualsiasi tipo che supporta begin() e cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

Restituisce un iteratore const che punta alla posizione oltre l'ultimo elemento di un intervallo.

const_iterator cend() const;

Valore restituito

Iteratore di accesso bidirezionale const che punta oltre la fine dell'intervallo.

Osservazioni:

cend viene utilizzato per verificare se un iteratore ha superato la fine del relativo intervallo.

È possibile usare questa funzione membro anziché la funzione membro end() per garantire che il valore restituito sia const_iterator. In genere, viene usato insieme alla parola chiave di deduzione del auto tipo, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile di qualsiasi tipo che supporta end() e cend().

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

// i2 is Container<T>::const_iterator

Non è consigliabile dereferenziare il valore restituito da cend.

`clear`

Cancella tutti gli elementi di una mappa.

void clear();

Esempio

Nell'esempio seguente viene illustrato l'uso della map::clear funzione membro.

// 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`

Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento const nel map.

typedef implementation-defined const_iterator;

Osservazioni:

Non è possibile usare un tipo const_iterator per modificare il valore di un elemento.

L'oggetto const_iterator definito dalla mappa punta a elementi di value_type, ovvero di tipo pair<constKey, Type>, il cui primo membro è la chiave dell'elemento e il cui secondo membro è il datum mappato mantenuto dall'elemento .

Per dereferenziare un const_iterator cIter elemento in una mappa, usare l'operatore -> .

Per accedere al valore della chiave per l'elemento, usare cIter ->first, equivalente a (* cIter). first.

Per accedere al valore del datum mappato per l'elemento, usare cIter ->second, equivalente a (* cIter). second.

Esempio

Vedere l'esempio per begin un esempio che usa const_iterator.

`const_pointer`

Tipo che fornisce un puntatore a un const elemento in una mappa.

typedef typename allocator_type::const_pointer const_pointer;

Osservazioni:

Non è possibile usare un tipo const_pointer per modificare il valore di un elemento.

Nella maggior parte dei casi, un oggetto iterator deve essere utilizzato per accedere agli elementi in un oggetto mappa.

`const_reference`

Tipo che fornisce un riferimento a un const elemento archiviato in una mappa per la lettura e l'esecuzione di const operazioni.

typedef typename allocator_type::const_reference const_reference;

Esempio

// 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`

Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento const nel map.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Osservazioni:

Un tipo const_reverse_iterator non può modificare il valore di un elemento e viene usato per scorrere la mappa inversa.

L'oggetto const_reverse_iterator definito dalla mappa punta a elementi di value_type, ovvero di tipo pair<const Key, Type>, il cui primo membro è la chiave dell'elemento e il cui secondo membro è il datum mappato mantenuto dall'elemento .

Per dereferenziare un tipo const_reverse_iterator crIter che punta a un elemento in un oggetto map, usare l'operatore ->.

Per accedere al valore della chiave per l'elemento, usare crIter ->first, equivalente a (* crIter).first.

Per accedere al valore del datum mappato per l'elemento, usare crIter ->second, che equivale a (* crIter).first.

Esempio

Vedere l'esempio per rend un esempio di come dichiarare e usare const_reverse_iterator.

`count`

Restituisce il numero di elementi di una mappa la cui chiave corrisponde a una chiave specificata dal parametro.

size_type count(const Key& key) const;

Parametri

key
Valore chiave degli elementi per cui trovare un corrispondenza nella mappa.

Valore restituito

1 se la mappa contiene un elemento la cui chiave di ordinamento corrisponde alla chiave del parametro. 0 se la mappa non contiene un elemento con una chiave corrispondente.

Osservazioni:

La funzione membro restituisce il numero di elementi x nell'intervallo

[ lower_bound(key), upper_bound(key) )

corrispondente a 0 o 1 nel caso della mappa, che è un contenitore associativo univoco.

Esempio

Nell'esempio seguente viene illustrato l'uso della map::count funzione membro.

// 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`

Controlla se è presente un elemento con la chiave specificata in map.

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

Parametri

K
Tipo di chiave.

key
Valore della chiave dell'elemento da cercare.

Valore restituito

true se l'elemento viene trovato nel contenitore; false altrimenti.

Osservazioni:

contains() è una novità di C++20. Per usarlo, specificare l'opzione del /std:c++20 compilatore o versione successiva.

template<class K> bool contains(const K& key) const partecipa alla risoluzione dell'overload solo se key_compare è trasparente. Per altre informazioni, vedere Ricerca eterogenea nei contenitori associativi .

Esempio

// 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`

Restituisce un iteratore const che punta al primo elemento di un oggetto map invertito.

const_reverse_iterator crbegin() const;

Valore restituito

Iteratore bidirezionale const inverso che punta al primo elemento di un oggetto invertito map o che punta a ciò che era stato l'ultimo elemento nell'oggetto non invertito map.

Osservazioni:

crbegin viene usato con un oggetto invertito map esattamente come begin viene usato con un oggetto map.

Con il valore restituito di crbegin, l'oggetto map non può essere modificato

crbegin può essere usato per eseguire l'iterazione all'indietro su un oggetto map.

Esempio

// 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`

Restituisce un iteratore const che punta alla posizione successiva all'ultimo elemento di un oggetto map invertito.

const_reverse_iterator crend() const;

Valore restituito

Iteratore bidirezionale const inverso che punta alla posizione successiva all'ultimo elemento di un oggetto invertito (la posizione che aveva preceduto map il primo elemento nell'oggetto non invertito map).

Osservazioni:

crend viene usato con una mappa invertita esattamente come end viene usata con un oggetto map.

Con il valore restituito di crend, l'oggetto map non può essere modificato.

crend può essere usato per verificare se un iteratore inverso ha raggiunto la fine dell'oggetto map.

Non è consigliabile dereferenziare il valore restituito da crend.

Esempio

// 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`

Tipo Signed Integer che può essere usato per rappresentare il numero di elementi di un oggetto map in un intervallo compreso tra gli elementi a cui puntano gli iteratori.

typedef allocator_type::difference_type difference_type;

Osservazioni:

difference_type è il tipo restituito quando si sottrae o si incrementa tramite gli iteratori del contenitore. difference_type viene in genere usato per rappresentare il numero di elementi nell'intervallo [ first, last) tra gli iteratori first e last, includendo l'elemento a cui punta first e l'intervallo di elementi fino all'elemento a cui punta last, escluso tale elemento.

Sebbene difference_type sia disponibile per tutti gli iteratori che soddisfano i requisiti di un iteratore di input, che include la classe di iteratori bidirezionali supportati da contenitori reversibili, ad esempio set, la sottrazione tra iteratori è supportata solo dagli iteratori ad accesso casuale forniti da un contenitore di accesso casuale, ad esempio vector.

Esempio

// 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`

Inserisce un elemento costruito sul posto, senza che vengano eseguite operazioni di copia o spostamento.

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

Parametri

args
Argomenti inoltrati per costruire un elemento da inserire nella mappa, a meno che non contenga già un elemento il cui valore è ordinato in modo equivalente.

Valore restituito

Oggetto pair il cui bool componente è true se è stato eseguito un inserimento e false se la mappa contiene già un elemento di valore equivalente nell'ordinamento. Il componente dell'iteratore della coppia di valori restituita punta all'elemento appena inserito se il componente bool è true oppure all'elemento esistente se il componente bool è false.

Per accedere al componente iteratore di un pair proggetto , usare pr.first; per dereferenziarlo, usare *pr.first. Per accedere al componente bool, usare pr.second. Per un esempio, vedere il codice di esempio più avanti in questo articolo.

Osservazioni:

Questa funzione non invalida alcun iteratore né riferimento.

Durante l'inserimento, se viene generata un'eccezione, lo stato del contenitore non viene modificato.

L'oggetto value_type di un elemento è una coppia, in modo che il valore di un elemento sia una coppia ordinata con il primo componente uguale al valore della chiave e il secondo componente uguale al valore di dati dell'elemento.

Esempio

// 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`

Inserisce un elemento costruito in locale (senza che vengano eseguite operazioni di copia o di spostamento), con un suggerimento sulla posizione.

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

Parametri

args
Gli argomenti inoltrati per costruire un elemento da inserire nella mappa, a meno che la mappa non contenga già tale elemento o, più in generale, a meno che non contenga già un elemento la cui chiave è ordinata in modo equivalente.

where
Posizione in cui iniziare a cercare il punto di inserimento corretto. Se tale punto precede immediatamente dove, l'inserimento può verificarsi in tempo costante ammortizzato anziché in tempo logaritmico.

Valore restituito

Iteratore all'elemento appena inserito.

Se l'inserimento ha avuto esito negativo perché l'elemento esiste già, restituisce un iteratore all'elemento esistente con la relativa chiave.

Osservazioni:

Questa funzione non invalida alcun iteratore né riferimento.

Durante l'inserimento, se viene generata un'eccezione, lo stato del contenitore non viene modificato.

Esempio

// 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`

Verifica se un oggetto map è vuoto.

bool empty() const;

Valore restituito

true se la mappa è vuota; false se la mappa non èempty.

Esempio

// 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`

Restituisce l'iteratore successivo all'ultimo valore.

const_iterator end() const;

iterator end();

Valore restituito

Iteratore successivo all'ultimo valore. Se la mappa è vuota, verrà restituito map::end() == map::begin().

Osservazioni:

end viene usato per verificare se un iteratore ha superato la fine della mappa.

Non è consigliabile dereferenziare il valore restituito da end.

Per un esempio di codice, vedere map::find.

`equal_range`

Restituisce una coppia di iteratori che rappresentano l'oggetto lower_bound della chiave e upper_bound della chiave.

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

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

Parametri

key
Valore della chiave dell'argomento per cui trovare una corrispondenza con la chiave di ordinamento di un elemento presente nell'oggetto map in cui si esegue la ricerca.

Valore restituito

Per accedere al primo iteratore di una coppia pr restituita dalla funzione membro, usare pr. per prima cosa e per dereferenziare l'iteratore con limite inferiore, usare *( pr. first). Per accedere al secondo iteratore di una coppia pr restituita dalla funzione membro, usare pr. second, e per dereferenziare l'iteratore superiore associato, usare *( pr. secondo).

Esempio

// 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`

Rimuove un elemento o un intervallo di elementi di un oggetto map dalle posizioni specificate oppure rimuove gli elementi che corrispondono a una chiave specificata.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parametri

Where
Posizione dell'elemento che deve essere rimosso.

First
Posizione del primo elemento che deve essere rimosso.

Last
Posizione immediatamente successiva all'ultimo elemento che deve essere rimosso.

Key
Valore della chiave dell'elemento che deve essere rimosso.

Valore restituito

Per le prime due funzioni membro, iteratore bidirezionale che definisce il primo elemento rimanente oltre gli eventuali elementi rimossi o elemento che rappresenta la fine dell'oggetto map se tali elementi non sono presenti.

Per la terza funzione membro, restituisce il numero di elementi rimossi dall'oggetto map.

Esempio

// 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`

Restituisce un iteratore che fa riferimento alla posizione di un elemento in una mappa che contiene una chiave equivalente a una chiave specificata.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametri

key
Valore chiave per cui trovare una corrispondenza con la chiave di ordinamento di un elemento presente nella mappa in cui eseguire la ricerca.

Valore restituito

Iteratore che fa riferimento alla posizione di un elemento con una chiave specificata o alla posizione successiva all'ultimo elemento in map (map::end()) se non viene trovata alcuna corrispondenza per la chiave.

Osservazioni:

La funzione membro restituisce un iteratore che fa riferimento a un elemento nella map cui chiave di ordinamento è equivalente alla chiave dell'argomento in un predicato binario che induce un ordinamento basato su una relazione di confronto minore di.

Se il valore restituito di find viene assegnato a un const_iteratoroggetto , l'oggetto map non può essere modificato. Se il valore restituito di find viene assegnato a un iteratoroggetto , l'oggetto map può essere modificato

Esempio

// 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`

Restituisce una copia dell'oggetto allocatore usato per costruire l'oggetto map.

allocator_type get_allocator() const;

Valore restituito

Allocatore usato dall'oggetto map.

Osservazioni:

Gli allocatori per la classe map specificano il modo in cui la classe gestisce l'archiviazione. Gli allocatori predefiniti acclusi alle classi contenitore della libreria standard C++ sono sufficienti per la maggior parte delle esigenze di programmazione. Scrivere e usare una classe allocator personalizzata è un argomento di C++ avanzato.

Esempio

// 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`

Inserisce un elemento o un intervallo di elementi in una mappa.

// (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);

Parametri

Val
Valore di un elemento da inserire nella mappa, a meno che non contenga già un elemento la cui chiave è ordinata in modo equivalente.

Where
Posizione in cui iniziare a cercare il punto di inserimento corretto. Se tale punto è immediatamente seguito da Where, l'inserimento può avvenire in tempo costante ammortizzato anziché in tempo logaritmico.

ValTy
Parametro modello che specifica il tipo di argomento che la mappa può usare per costruire un elemento di value_typee forward Val perfetti come argomento.

First
Posizione del primo elemento da copiare.

Last
Posizione immediatamente dopo l'ultimo elemento da copiare.

InputIterator
Argomento della funzione modello che soddisfa i requisiti di un iteratore di input che punta agli elementi di un tipo che può essere usato per costruire value_type oggetti.

IList
Oggetto initializer_list da cui copiare gli elementi.

Valore restituito

Le funzioni membro a singolo elemento, (1) e (2), restituiscono un pair il cui bool componente è true se è stato effettuato un inserimento e false se la mappa contiene già un elemento la cui chiave ha un valore equivalente nell'ordinamento. Il componente dell'iteratore della coppia di valori restituita punta all'elemento appena inserito se il componente bool è true oppure all'elemento esistente se il componente bool è false.

Le funzioni membro a elemento singolo con suggerimento, (3) e (4), restituiscono un iteratore che punta alla posizione in cui il nuovo elemento è stato inserito nella mappa o all'elemento già esistente, se esiste un elemento con una chiave equivalente.

Osservazioni:

Non ci sono iteratori, puntatori o riferimenti invalidati da questa funzione.

Durante l'inserimento di un solo elemento, se viene generata un'eccezione, lo stato del contenitore non viene modificato. Se viene generata un'eccezione durante l'inserimento di più elementi, il contenitore viene lasciato in uno stato non specificato ma comunque valido.

Per accedere al componente iteratore di un pair pr oggetto restituito dalle funzioni membro a singolo elemento, usare pr.first; per dereferenziare l'iteratore all'interno della coppia restituita, usare *pr.first, fornendo un elemento . Per accedere al componente bool, usare pr.second. Per un esempio, vedere il codice di esempio più avanti in questo articolo.

L'oggetto value_type di un contenitore è un typedef che appartiene al contenitore e per map map<K, V>::value_type è pair<const K, V>. Il valore di un elemento è una coppia ordinata in cui il primo componente equivale al valore della chiave e il secondo componente equivale al valore dati dell'elemento.

La funzione membro di intervallo (5) inserisce la sequenza di valori di elemento in una mappa che corrisponde a ogni elemento interessato da un iteratore nell'intervallo [First, Last). Non viene quindi inserito Last. La funzione membro di contenitore end() fa riferimento alla posizione immediatamente dopo l'ultimo elemento nel contenitore. L'istruzione m.insert(v.begin(), v.end());, ad esempio, cerca di inserire tutti gli elementi di v in m. Solo gli elementi che hanno valori univoci nell'intervallo vengono inseriti; i duplicati vengono ignorati. Per osservare quali elementi vengono rifiutati, usare le versioni con un singolo elemento di insert.

La funzione membro dell'elenco di inizializzatori (6) usa un initializer_list oggetto per copiare gli elementi nella mappa.

Per l'inserimento di un elemento costruito sul posto, ovvero non vengono eseguite operazioni di copia o spostamento, vedere map::emplace e map::emplace_hint.

Esempio

// 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`

Tipo che fornisce un iteratore bidirezionale in grado di leggere o modificare qualsiasi elemento di un oggetto map.

typedef implementation-defined iterator;

Osservazioni:

L'iteratore definito dalla mappa punta a elementi di value_type, ovvero di tipo pair<const Key, Type>, il cui primo membro è la chiave dell'elemento e il cui secondo membro è il datum mappato mantenuto dall'elemento .

Per dereferenziare un iteratore che punta a un elemento in una mappa, usare l'operatore -> .

Per accedere al valore della chiave per l'elemento, usare Iter->first, equivalente a (*Iter).first. Per accedere al valore del datum mappato per l'elemento, usare Iter->second, che equivale a (*Iter).second.

Esempio

Vedere l'esempio per begin un esempio di come dichiarare e usare iterator.

`key_comp`

Recupera una copia dell'oggetto di confronto usato per ordinare le chiavi di un oggetto map.

key_compare key_comp() const;

Valore restituito

Oggetto funzione che viene usato da un oggetto map per ordinare gli elementi.

Osservazioni:

L'oggetto archiviato definisce la funzione membro

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

che restituisce true se left precede e non è uguale a right nell'ordinamento.

Esempio

// 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`

Tipo che fornisce un oggetto funzione in grado di confrontare due chiavi di ordinamento per determinare l'ordine relativo di due elementi nel map.

typedef Traits key_compare;

Osservazioni:

key_compare è un sinonimo per il parametro di modello Traits.

Per altre informazioni su Traits, vedere l'argomento map Classe .

Esempio

Vedere l'esempio per key_comp un esempio di come dichiarare e usare key_compare.

`key_type`

Tipo che descrive la chiave di ordinamento archiviata in ogni elemento dell'oggetto map.

typedef Key key_type;

Osservazioni:

key_type è un sinonimo per il parametro di modello Key.

Per altre informazioni su Key, vedere la sezione Osservazioni dell'argomento map Classe .

Esempio

Vedere l'esempio per value_type un esempio di come dichiarare e usare key_type.

`lower_bound`

Restituisce un iteratore al primo elemento di un oggetto map con un valore della chiave uguale o maggiore di quello di una chiave specificata.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parametri

key
Valore della chiave dell'argomento per cui trovare una corrispondenza con la chiave di ordinamento di un elemento presente nell'oggetto map in cui si esegue la ricerca.

Valore restituito

Oggetto iterator o const_iterator che punta alla posizione di un elemento in una mappa con una chiave uguale o maggiore della chiave dell'argomento oppure che punta alla posizione successiva all'ultimo elemento in map se non viene trovata alcuna corrispondenza per la chiave.

Se il valore restituito di lower_bound viene assegnato a un const_iteratoroggetto , l'oggetto map non può essere modificato. Se il valore restituito di lower_bound viene assegnato a un iteratoroggetto , è possibile modificare l'oggetto map.

Esempio

// 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`

Costruisce un oggetto map vuoto o che rappresenta una copia totale o parziale di un altro oggetto 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);

Parametri

Al
Classe dell'allocatore di archiviazione da usare per l'oggetto map. Per impostazione predefinita è Allocator.

Comp
Funzione di confronto di tipo const Traits usata per ordinare gli elementi nell'oggetto map. Per impostazione predefinita è hash_compare.

Right
Oggetto map di cui il set costruito deve essere una copia.

First
Posizione del primo elemento nell'intervallo di elementi da copiare.

Last
Posizione del primo elemento oltre l'intervallo di elementi da copiare.

IList
Oggetto initializer_list da cui devono essere copiati gli elementi.

Osservazioni:

Tutti i costruttori archiviano un tipo di oggetto allocatore che gestisce l'archiviazione di memoria per la mappa e che può essere restituito in un secondo momento chiamando get_allocator. Il parametro allocator viene spesso omesso nelle dichiarazioni di classe e vengono usate macro di pre-elaborazione per introdurre allocatori alternativi.

Tutti i costruttori inizializzano il relativo oggetto map.

Tutti i costruttori archiviano un oggetto funzione di tipo Traits usato per stabilire un ordine tra le chiavi della mappa e che possono essere restituite in un secondo momento chiamando key_comp.

I primi tre costruttori specificano una mappa iniziale vuota, la seconda specifica il tipo di funzione di confronto (Comp) da utilizzare per stabilire l'ordine degli elementi e la terza specifica in modo esplicito il tipo di allocatore (Al). La parola chiave explicit elimina alcuni tipi di conversione automatica del tipo.

Il quarto costruttore specifica una copia dell'oggetto map Right.

Il quinto costruttore specifica una copia dell'oggetto map tramite lo spostamento di Right.

I costruttori 6, 7 e 8 utilizzano un oggetto initializer_list da cui copiare i membri.

I tre costruttori successivi copiano l'intervallo [First, Last) di un oggetto map con un grado di esplicitazione crescente nello specificare il tipo di funzione di confronto della classe Traits e il tipo di allocatore.

Esempio

// 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`

Tipo che rappresenta il tipo di dati archiviato in un oggetto map.

typedef Type mapped_type;

Osservazioni:

Il tipo mapped_type è un sinonimo del parametro di modello Type della classe.

Per altre informazioni su Type, vedere l'argomento map Classe .

Esempio

Vedere l'esempio per value_type un esempio di come dichiarare e usare mapped_type.

`max_size`

Restituisce la lunghezza massima della mappa.

size_type max_size() const;

Valore restituito

Massima lunghezza possibile dell'oggetto map.

Esempio

// 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[]`

Inserisce un elemento in una mappa con un valore di chiave specificato.

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

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

Parametri

key
Valore della chiave dell'elemento da inserire.

Valore restituito

Riferimento al valore dei dati dell'elemento inserito.

Osservazioni:

Se il valore della chiave dell'argomento non viene trovato, viene inserito insieme al valore predefinito del tipo di dati.

operator[] può essere usato per inserire elementi in un oggetto map m tramite m[key] = DataValue;, dove DataValue è il valore di mapped_type dell'elemento con un valore di chiave key.

Quando si utilizza operator[] per inserire gli elementi, il riferimento restituito non indica se un inserimento modifica un elemento già esistente o ne crea uno nuovo. Le funzioni find membro e insert possono essere utilizzate per determinare se un elemento con una chiave specificata è già presente prima di un inserimento.

Esempio

// 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=`

Sostituisce gli elementi di una mappa con una copia di un'altra mappa.

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

Parametri

right
Oggetto map copiato in map.

Osservazioni:

Dopo la cancellazione di tutti gli elementi esistenti in un oggetto map, operator= copia o sposta il contenuto di right nell'oggetto map.

Esempio

// 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`

Tipo che fornisce un puntatore a un elemento di un oggetto map.

typedef typename allocator_type::pointer pointer;

Osservazioni:

È possibile utilizzare un tipo pointer per modificare il valore di un elemento.

Nella maggior parte dei casi, un oggetto iterator deve essere utilizzato per accedere agli elementi in un oggetto mappa.

rbegin

Restituisce un iteratore che punta al primo elemento di un oggetto map invertito.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valore restituito

Iteratore bidirezionale inverso che punta al primo elemento di un oggetto map invertito o a quello che è stato l'ultimo elemento dell'oggetto map non invertito.

Osservazioni:

rbegin viene usato con una mappa invertita esattamente come begin viene usata con una mappa.

Se il valore restituito di rbegin viene assegnato a un const_reverse_iteratoroggetto , l'oggetto map non può essere modificato. Se il valore restituito di rbegin viene assegnato a un reverse_iterator, l'oggetto map può essere modificato.

rbegin può essere usato per eseguire l'iterazione all'indietro su un oggetto map.

Esempio

// 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`

Tipo che fornisce un riferimento a un elemento archiviato in un oggetto map.

typedef typename allocator_type::reference reference;

Esempio

// 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`

Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un oggetto map invertito.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valore restituito

Iteratore bidirezionale inverso che punta alla posizione successiva all'ultimo elemento di un oggetto map invertito, ovvero la posizione che precedeva il primo elemento dell'oggetto map non invertito.

Osservazioni:

rend viene usato con una mappa invertita esattamente come end viene usata con una mappa.

Se il valore restituito di rend viene assegnato a un const_reverse_iteratoroggetto , l'oggetto map non può essere modificato. Se il valore restituito di rend viene assegnato a un reverse_iterator, l'oggetto map può essere modificato.

rend può essere usato per verificare se un iteratore inverso ha raggiunto la fine del relativo oggetto map.

Non è consigliabile dereferenziare il valore restituito da rend.

Esempio

// 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`

Tipo che fornisce un iteratore bidirezionale in grado di leggere o modificare un elemento di un oggetto map invertito.

typedef std::reverse_iterator<iterator> reverse_iterator;

Osservazioni:

Un tipo reverse_iterator non può modificare il valore di un elemento e viene usato per scorrere la mappa inversa.

L'oggetto reverse_iterator definito dalla mappa punta a elementi di value_type, ovvero di tipo pair<const Key, Type>, il cui primo membro è la chiave dell'elemento e il cui secondo membro è il datum mappato mantenuto dall'elemento .

Per dereferenziare un reverse_iterator rIter che punta a un elemento in una mappa, usare l'operatore -> .

Per accedere al valore della chiave per l'elemento, usare rIter ->first, equivalente a (* rIter). first. Per accedere al valore del datum mappato per l'elemento, usare rIter ->second, che equivale a (* rIter). first.

Esempio

Vedere l'esempio per rbegin un esempio di come dichiarare e usare reverse_iterator.

`size`

Restituisce il numero di elementi nel map.

size_type size() const;

Valore restituito

La lunghezza corrente dell'oggetto map.

Esempio

Nell'esempio seguente viene illustrato l'uso della map::size funzione membro.

// 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`

Tipo Unsigned Integer in grado di rappresentare il numero di elementi di un oggetto map.

typedef typename allocator_type::size_type size_type;

Esempio

Vedere l'esempio per size un esempio di come dichiarare e usare size_type.

scambio

Scambia gli elementi di due oggetti map.

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

Parametri

right
Argomento di tipo map che fornisce gli elementi da scambiare con l'oggetto map di destinazione.

Osservazioni:

La funzione membro non invalida riferimenti, puntatori o iteratori che designano gli elementi dei due oggetti map di cui vengono scambiati gli elementi.

Esempio

// 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`

Restituisce un iteratore al primo elemento di un oggetto map con un valore della chiave maggiore di quello di una chiave specificata.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parametri

key
Valore della chiave dell'argomento per cui trovare una corrispondenza con il valore della chiave di ordinamento di un elemento presente nell'oggetto map in cui si esegue la ricerca.

Valore restituito

Oggetto iterator o const_iterator che punta alla posizione di un elemento in una mappa con una chiave maggiore della chiave dell'argomento o che punta alla posizione successiva all'ultimo elemento in map se non viene trovata alcuna corrispondenza per la chiave.

Se il valore restituito viene assegnato a un const_iteratoroggetto , l'oggetto map non può essere modificato. Se il valore restituito viene assegnato a un iteratoroggetto , è possibile modificare l'oggetto map.

Esempio

// 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 funzione membro restituisce un oggetto funzione che determina l'ordine degli elementi in un oggetto map confrontando i valori delle relative chiavi.

value_compare value_comp() const;

Valore restituito

Restituisce l'oggetto funzione di confronto che viene usato da un oggetto map per ordinare gli elementi.

Osservazioni:

Per una mappa m, se due elementi e1(k1, d1) ed e2(k2, d2) sono oggetti di tipo value_type, dove k1 e k1 sono le relative chiavi di tipo key_type e d1 e d2 sono i relativi dati di tipo mapped_type, allora m.value_comp(e1, e2) è equivalente a m.key_comp(k1, k2). Un oggetto archiviato definisce la funzione membro

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

che restituisce true se il valore della chiave di left precede e non è uguale al valore della chiave di right nell'ordinamento.

Esempio

// 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`

Tipo di oggetto archiviato come elemento di un oggetto map.

typedef pair<const Key, Type> value_type;

Esempio

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

Vedi anche

Contenitori
Thread Safety in the C++ Standard Library (Sicurezza dei thread nella libreria standard C++)
Informazioni di riferimento per la libreria standard C++

Condividi tramite

Classe map

Sintassi

Parametri

Osservazioni:

Membri

Costruttori

Typedef

Funzioni membro

Operatori

allocator_type

Esempio

at

Parametri

Valore restituito

Osservazioni:

Esempio

begin

Valore restituito

Esempio

cbegin

Valore restituito

Osservazioni:

cend

Valore restituito

Osservazioni:

clear

Esempio

const_iterator

Osservazioni:

Esempio

const_pointer

Osservazioni:

const_reference

Esempio

const_reverse_iterator

Osservazioni:

Esempio

count

Parametri

Valore restituito

Osservazioni:

Esempio

contains

Parametri

Valore restituito

Osservazioni:

Esempio

crbegin

Valore restituito

Osservazioni:

Esempio

crend

Valore restituito

Osservazioni:

Esempio

difference_type

Osservazioni:

Esempio

emplace

Parametri

Valore restituito

Osservazioni:

Esempio

emplace_hint

Parametri

Valore restituito

Osservazioni:

Esempio

empty

Valore restituito

Esempio

end

Valore restituito

Osservazioni:

equal_range

Parametri

Valore restituito

Esempio

erase

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`