Classe `multimap`

Articolo
06/16/2023

La classe multimap della libreria standard C++ viene usata per l'archiviazione e il recupero di dati da una raccolta in cui ogni elemento è una coppia con sia un valore di dati che una chiave di ordinamento. Il valore della chiave non deve essere univoco e viene usato per ordinare automaticamente i dati. Il valore di un elemento di un multimap, a differenza del valore della chiave associata, può essere direttamente modificato. I valori invece delle chiavi associati a elementi precedenti devono essere eliminati e i valori delle nuove chiavi devono essere associati ai nuovi elementi inseriti.

Sintassi

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

Parametri

Key
Tipo di dati della chiave da archiviare nel multimap.

Type
Tipo di dati degli elementi da archiviare nel multimap.

Traits
Tipo che fornisce un oggetto funzione in grado di confrontare i valori di due elementi come chiavi di ordinamento per determinarne l'ordine relativo nel multimap. Il predicato binario less<Key> rappresenta il valore predefinito.

In C++ 14 è possibile abilitare la ricerca eterogenea specificando il predicato std::less<> o std::greater<> che non ha alcun parametro 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 multimap della libreria standard C++ è:

Un contenitore associativo, che è un contenitore di dimensioni variabili che supporta il recupero efficiente dei valori degli elementi in base al valore di una chiave associata.
Reversibile, in quanto fornisce iteratori bidirezionali per accedere ai relativi elementi.
Ordinato, poiché i relativi elementi sono ordinati in base ai valori delle chiavi all'interno del contenitore conformemente a una funzione di confronto specificata.
Multiplo, perché i relativi elementi non devono avere una chiave univoca, in modo che a un valore chiave possano essere associati molti valori dei dati degli elementi.
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 quindi indipendente dal tipo specifico di dati contenuti come elementi o chiavi. I tipi di dati da utilizzare per gli elementi e le chiavi vengono invece specificati come parametri nel modello di classe i insieme alla funzione di confronto e all'allocatore.

L'iteratore fornito dalla classe map è un iteratore bidirezionale, ma le funzioni insert membro della classe e multimap hanno versioni che accettano come parametri di modello un iteratore di input più debole, i cui requisiti di funzionalità sono più minimi di quelli garantiti dalla classe di iteratori bidirezionali. I diversi concetti di iteratore formano una famiglia correlata dai perfezionamenti delle relative funzionalità. Ogni concetto di iteratore dispone di un set di requisiti e gli algoritmi utilizzati con tali concetti devono limitare le proprie ipotesi ai requisiti forniti da tale tipo di iteratore. Si può presupporre che un iteratore di input possa essere dereferenziato per fare riferimento a un determinato oggetto e possa essere incrementato all'iteratore successivo nella sequenza. Si tratta di un set di funzionalità minimo, ma è sufficiente per poter descrivere chiaramente un intervallo di iteratori [First, Last) nel contesto delle funzioni membro della classe.

La scelta del tipo di contenitore deve essere basata in genere sul tipo di ricerca e di 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 sono efficienti, eseguendo tali operazioni in un lasso di tempo mediamente proporzionale al logaritmo del numero di elementi presenti nel contenitore. L'inserimento di elementi non invalida alcun iteratore e la rimozione di elementi invalida solo gli iteratori che avevano puntato agli elementi rimossi.

Deve multimap essere il contenitore associativo scelto quando le condizioni che associano i valori alle relative chiavi vengono soddisfatte dall'applicazione. Un modello per questo tipo di struttura è un elenco ordinato di parole chiave con valori stringa associati che forniscono, ad esempio, definizioni, in cui le parole non sono sempre state definite in modo univoco. Nel caso invece in cui le parole chiave siano state definite in modo univoco, il contenitore da preferire è una mappa. Se invece è stato archiviato solo l'elenco di parole, il contenitore appropriato è rappresentato da un set. Se sono state consentite più occorrenze delle parole, una multiset sarà la struttura del contenitore appropriata.

Ordina multimap la sequenza che controlla chiamando un oggetto funzione archiviato di tipo key_compare. Questo oggetto archiviato è una funzione di confronto accessibile chiamando la funzione key_compmembro . In genere, gli elementi devono essere confrontabili come "minore di" per stabilire questo ordine: in modo che, dati qualsiasi due elementi, sia possibile determinare che sono equivalenti (ovvero che uno non è minore dell'altro) o che uno è minore dell'altro. Di conseguenza, l'ordinamento viene eseguito tra gli elementi non equivalenti. A un livello più tecnico, la funzione di confronto è un predicato binario che provoca un ordinamento di tipo "strict weak" nel senso matematico standard. Un predicato f(x,y) binario è un oggetto funzione con due oggetti x argomento e y un valore restituito di 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 sono definiti come equivalenti quando 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, in quanto tutti gli elementi vengono ordinati l'uno rispetto all'altro e le chiavi accoppiate saranno indistinguibili l'una dall'altra.

Membri

Costruttori

Costruttore	Descrizione
`multimap`	Costruisce un `multimap` vuoto o che rappresenta una copia totale o parziale di un altro `multimap`.

Typedef

Nome tipo	Descrizione
`allocator_type`	Tipo che rappresenta la classe `allocator` per l'oggetto `multimap`.
`const_iterator`	Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento `const` nel `multimap`.
`const_pointer`	Tipo che fornisce un puntatore a un elemento `const` in un `multimap`.
`const_reference`	Tipo che fornisce un riferimento a un elemento `const` archiviato in un `multimap` per la lettura e l'esecuzione di operazioni `const`.
`const_reverse_iterator`	Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento `const` nel `multimap`.
`difference_type`	Tipo Signed Integer che può essere utilizzato per rappresentare il numero di elementi di un `multimap` in un intervallo compreso tra gli elementi a cui puntano gli iteratori.
`iterator`	Tipo che fornisce la differenza tra due iteratori che fanno riferimento agli elementi all'interno dello stesso `multimap`.
`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 `multimap`.
`key_type`	Tipo che descrive l'oggetto chiave di ordinamento che costituisce ogni elemento dell'oggetto `multimap`.
`mapped_type`	Tipo che rappresenta il tipo di dati archiviati in un `multimap`.
`pointer`	Tipo che fornisce un puntatore a un elemento `const` in un `multimap`.
`reference`	Tipo che fornisce un riferimento a un elemento archiviato in un `multimap`.
`reverse_iterator`	Tipo che fornisce un iteratore bidirezionale in grado di leggere o modificare un elemento di un `multimap` invertito.
`size_type`	Tip Unsigned Integer che fornisce un puntatore a un elemento `const` di un `multimap`.
`value_type`	Tipo che fornisce un oggetto funzione in grado di confrontare due elementi come chiavi di ordinamento per determinarne l'ordine relativo nel `multimap`.

Funzioni membro

Funzione membro	Descrizione
`begin`	Restituisce un iteratore che punta al primo elemento del `multimap`.
`cbegin`	Restituisce un `const` iteratore che punta al primo elemento dell'oggetto `multimap`.
`cend`	Restituisce un `const` iteratore che punta alla posizione successiva all'ultimo elemento di un oggetto `multimap`.
`clear`	Cancella tutti gli elementi di un `multimap`.
`contains`^C++20	Controlla se è presente un elemento con la chiave specificata in `multimap`.
`count`	Restituisce il numero di elementi di un `multimap` la cui chiave corrisponde a una chiave specificata dal parametro.
`crbegin`	Restituisce un `const` iteratore che punta al primo elemento di un oggetto invertito `multimap`.
`crend`	Restituisce un `const` iteratore che punta alla posizione successiva all'ultimo elemento di un oggetto invertito `multimap`.
`emplace`	Inserisce un elemento costruito sul posto in un `multimap`.
`emplace_hint`	Inserisce un elemento costruito sul posto in un `multimap`, con un suggerimento sulla posizione.
`empty`	Verifica se un `multimap` è vuoto.
`end`	Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un `multimap`.
`equal_range`	Trova l'intervallo di elementi in cui la chiave dell'elemento corrisponde a un valore specificato.
`erase`	Rimuove un elemento o un intervallo di elementi di un `multimap` dalle posizioni specificate oppure rimuove gli elementi che corrispondono a una chiave specificata.
`find`	Restituisce un iteratore che punta alla prima posizione di un elemento di un `multimap` che dispone di una chiave equivalente a una chiave specificata.
`get_allocator`	Restituisce una copia dell'oggetto `allocator` utilizzato per costruire il `multimap`.
`insert`	Inserisce un elemento o un intervallo di elementi in un `multimap`.
`key_comp`	Recupera una copia dell'oggetto di confronto utilizzato per ordinare le chiavi di un `multimap`.
`lower_bound`	Restituisce un iteratore al primo elemento di un `multimap` con una chiave uguale o maggiore di una chiave specificata.
`max_size`	Restituisce la lunghezza massima del `multimap`.
`rbegin`	Restituisce un iteratore che punta al primo elemento di un `multimap` invertito.
`rend`	Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un `multimap` invertito.
`size`	Restituisce il numero di elementi nel `multimap`.
`swap`	Scambia gli elementi di due `multimap`.
`upper_bound`	Restituisce un iteratore al primo elemento di un `multimap` con una chiave maggiore di una chiave specificata.
`value_comp`	La funzione membro restituisce un oggetto funzione che determina l'ordine degli elementi in un `multimap` confrontando i valori delle relative chiavi.

Operatore	Descrizione
`operator=`	Sostituisce gli elementi di un `multimap` con una copia di un altro `multimap`.

Requisiti

Intestazione:<map>

Spazio dei nomistd:

Le coppie ( chiave, valore) vengono archiviate in come multimap oggetti di tipo pair. La classe pair richiede l'intestazione <utility>, inclusa automaticamente da <map>.

`multimap::allocator_type`

Tipo che rappresenta la classe allocatore per l'oggetto multimap .

typedef Allocator allocator_type;

Esempio

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

`multimap::begin`

Restituisce un iteratore che punta al primo elemento del multimap.

const_iterator begin() const;

iterator begin();

Valore restituito

Iteratore bidirezionale che punta al primo elemento nell'oggetto multimap o alla posizione successiva a un oggetto vuoto multimap.

Esempio

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

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

   multimap <int, int> :: iterator m1_Iter;
   multimap <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 as the iterator is const
   // m1_cIter = m1.begin ( );
   // m1.erase ( m1_cIter );

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

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

`multimap::cbegin`

Restituisce un iteratore const che punta al primo elemento dell'intervallo.

const_iterator cbegin() const;

Valore restituito

Iteratore di accesso 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

`multimap::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

Il valore restituito da cend non deve essere dereferenziato.

`multimap::clear`

Cancella tutti gli elementi di un multimap.

void clear();

Esempio

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

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

int main( )
{
   using namespace std;
   multimap<int, int> m1;
   multimap<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 multimap is initially "
        << i << "." << endl;

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

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

`multimap::const_iterator`

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

typedef implementation-defined const_iterator;

Osservazioni:

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

Oggetto const_iterator definito da multimap punta a oggetti di value_type, che sono di tipo pair<const Key, Type>. Il valore della chiave è disponibile tramite il primo membro della coppia e il valore dell'elemento mappato è disponibile tramite il secondo membro della coppia.

Per dereferenziare un const_iteratorcIter elemento in un multimapoggetto , 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, che equivale a (*cIter).second.

Esempio

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

`multimap::const_pointer`

Tipo che fornisce un puntatore a un elemento const in un multimap.

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 multimap oggetto .

`multimap::const_reference`

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

typedef typename allocator_type::const_reference const_reference;

Esempio

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

int main( )
{
   using namespace std;
   multimap <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 the first element in the multimap 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 the first element in the multimap is "
        << Ref2 << "." << endl;
}

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

`multimap::const_reverse_iterator`

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

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 l'oggetto multimap inverso.

Oggetto const_reverse_iterator definito da multimap punta a oggetti di value_type, che sono di tipo pair<const Key, Type>. Il valore della chiave è disponibile tramite il primo membro della coppia e il valore dell'elemento mappato è disponibile tramite il secondo membro della coppia.

Per dereferenziare un tipo const_reverse_iteratorcrIter che punta a un elemento in un oggetto multimap, 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.

`multimap::contains`

Controllare se è presente un elemento con la chiave specificata in multimap.

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::multimap<int, bool> m = {{0, false}, {1, true}};

    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::multimap<std::string, int, std::less<>> m2 = {{"ten", 10}, {"twenty", 20}, {"thirty", 30}};
    std::cout << m2.contains("ten");

    return 0;
}

true
false
true

`multimap::count`

Restituisce il numero di elementi in un oggetto multimap le cui chiavi corrispondono a una chiave specificata dal parametro.

size_type count(const Key& key) const;

Parametri

key
La chiave degli elementi per cui trovare un corrispondenza nel multimap.

Valore restituito

Il numero di elementi le cui chiavi di ordinamento corrispondono alla chiave del parametro; 0 se multimap non contiene un elemento con una chiave corrispondente.

Osservazioni:

La funzione membro restituisce il numero di elementi nell'intervallo

lower_bound(key), upper_bound(key)

con un valore di chiave key.

Esempio

L'esempio seguente illustra l'uso della funzione membro multimap::count.

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

int main( )
{
    using namespace std;
    multimap<int, int> m1;
    multimap<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));

    // Elements don't need to have unique keys in multimap,
    // so duplicates are allowed and counted
    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: 2.
The number of elements in m1 with a sort key of 2 is: 2.
The number of elements in m1 with a sort key of 3 is: 0.

`multimap::crbegin`

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

const_reverse_iterator crbegin() const;

Valore restituito

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

Osservazioni:

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

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

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

Esempio

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

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

   multimap <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 multimap m1 is "
        << m1_crIter -> first << "." << endl;
}

The first element of the reversed multimap m1 is 3.

`multimap::crend`

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

const_reverse_iterator crend() const;

Valore restituito

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

Osservazioni:

crend viene usato con un oggetto invertito multimap esattamente come multimap::end viene usato con un oggetto multimap.

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

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

Il valore restituito da crend non deve essere dereferenziato.

Esempio

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

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

   multimap <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 multimap m1 is "
        << m1_crIter -> first << "." << endl;
}

The last element of the reversed multimap m1 is 1.

`multimap::difference_type`

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

typedef typename allocator_type::difference_type difference_type;

Osservazioni:

difference_type è il tipo restituito quando si sottrae o si incrementa tramite gli iteratori del contenitore. Viene difference_type in genere utilizzato per rappresentare il numero di elementi nell'intervallo [first, last) tra gli first iteratori e last, include l'elemento a first cui punta e l'intervallo di elementi fino a , ma non incluso, l'elemento a lastcui punta .

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 ad accesso casuale, ad esempio vector.

Esempio

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

int main( )
{
   using namespace std;
   multimap <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 ) );

   // The following will insert as multimap keys are not unique
   m1.insert ( Int_Pair ( 2, 30 ) );

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

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

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

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

`multimap::emplace`

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

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

Parametri

args
Argomenti inoltrati per costruire un elemento da inserire nell'oggetto multimap.

Valore restituito

Iteratore all'elemento appena inserito.

Osservazioni:

Questa funzione non invalida alcun riferimento a elementi del contenitore, ma potrebbe invalidare tutti gli iteratori per il contenitore.

Se viene generata un'eccezione durante l'inserimento, il contenitore rimane invariato e viene nuovamente generata l'eccezione.

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

// multimap_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()
{
    multimap<string, string> m1;

    m1.emplace("Anna", "Accounting");
    m1.emplace("Bob", "Accounting");
    m1.emplace("Carmine", "Engineering");

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

    m1.emplace("Bob", "Engineering");

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

`multimap::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
Argomenti inoltrati per costruire un elemento da inserire nell'oggetto multimap.

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.

Valore restituito

Iteratore all'elemento appena inserito.

Osservazioni:

Questa funzione non invalida alcun riferimento a elementi del contenitore, ma potrebbe invalidare tutti gli iteratori per il contenitore.

Se viene generata un'eccezione durante l'inserimento, lo stato del contenitore non viene modificato.

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

`multimap::empty`

Verifica se un multimap è vuoto.

bool empty() const;

Valore restituito

true se l'oggetto multimap è vuoto; false se l'oggetto multimap è non vuoto.

Esempio

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

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

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

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

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

The multimap m1 is not empty.
The multimap m2 is empty.

`multimap::end`

Restituisce l'iteratore successivo all'ultimo valore.

const_iterator end() const;

iterator end();

Valore restituito

Iteratore successivo all'ultimo valore. Se l'oggetto multimap è vuoto, multimap::end() == multimap::begin().

Osservazioni:

end viene usato per verificare se un iteratore ha superato la fine del relativo multimap.

Il valore restituito da end non deve essere dereferenziato.

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

`multimap::equal_range`

Trova l'intervallo di elementi in cui la chiave dell'elemento corrisponde a un valore specificato.

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

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

Parametri

key
Chiave dell'argomento multimap da confrontare con la chiave di ordinamento di un elemento dalla ricerca.

Valore restituito

Coppia di iteratori in modo che il primo sia la lower_bound chiave e la seconda sia la upper_bound chiave.

Per accedere al primo iteratore di una coppia pr restituita dalla funzione membro, usare pr.first e per dereferenziare l'iteratore associato 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.second).

Esempio

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

int main( )
{
   using namespace std;
   typedef multimap <int, int, less<int> > IntMMap;
   IntMMap m1;
   multimap <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 <IntMMap::const_iterator, IntMMap::const_iterator> p1, p2;
   p1 = m1.equal_range( 2 );

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

   cout << "The upper bound of the element with "
        << "a key of 2 in the multimap 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 multimap m1 doesn't have an element "
           << "with a key less than 4." << endl;
   else
      cout << "The element of multimap m1 with a key >= 40 is: "
           << p1.first -> first << "." << endl;
}

The lower bound of the element with a key of 2 in the multimap m1 is: 20.
The upper bound of the element with a key of 2 in the multimap 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 multimap m1 doesn't have an element with a key less than 4.

`multimap::erase`

Rimuove un elemento o un intervallo di elementi di un multimap 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
Chiave degli elementi da rimuovere.

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 da multimap.

Osservazioni:

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

`multimap::find`

Restituisce un iteratore che fa riferimento alla prima posizione di un elemento in un multimap oggetto con una chiave equivalente a una chiave specificata.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametri

key
Valore della chiave da trovare in base alla chiave di ordinamento di un elemento dall'oggetto di cui viene eseguita la multimap ricerca.

Valore restituito

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

Osservazioni:

La funzione membro restituisce un iteratore che fa riferimento a un elemento nella multimap 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 multimap non può essere modificato. Se il valore restituito di find viene assegnato a un iteratoroggetto , l'oggetto multimap 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()
{
    multimap<int, string> m1({ { 40, "Zr" }, { 45, "Rh" } });
    cout << "The starting multimap 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 multimap m1 is (key, value):" << endl;
    print_collection(m1);
    cout << endl;
    findit(m1, 45);
    findit(m1, 6);
}

`multimap::get_allocator`

Restituisce una copia dell'oggetto allocatore utilizzato per costruire l'oggetto multimap.

allocator_type get_allocator() const;

Valore restituito

Allocatore utilizzato dall'oggetto multimap.

Osservazioni:

Gli allocatori per la multimap classe 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

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

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

   // The following lines declare objects
   // that use the default allocator.
   multimap <int, int> m1;
   multimap <int, int, allocator<int> > m2;
   multimap <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"
        << endl << "before free memory is exhausted: "
        << m2.max_size( ) << ".\n" << endl;

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

   // The following line creates a multimap m4
   // with the allocator of multimap 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 via the other
   if( m1_Alloc == m4_Alloc )
   {
      cout << "The allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "The allocators are not interchangeable."
           << endl;
   }
}

`multimap::insert`

Inserisce un elemento o un intervallo di elementi in un multimap.

// (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 nell'oggetto multimap.

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 input iteratore 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 single-element-insert, (1) e (2), restituiscono un iteratore alla posizione in cui è stato inserito il nuovo elemento nell'oggetto multimap.

Le funzioni membro single-element-with-hint, (3) e (4), restituiscono un iteratore che punta alla posizione in cui è stato inserito il nuovo elemento nell'oggetto multimap.

Osservazioni:

Questa funzione non invalida alcun puntatore o riferimento, ma potrebbe invalidare tutti gli iteratori per il contenitore.

Se viene generata un'eccezione durante l'inserimento di un solo elemento, ma l'eccezione non si manifesta nella funzione hash del contenitore, lo stato del contenitore non verrà modificato. Se viene generata un'eccezione durante l'inserimento di più elementi, il contenitore viene lasciato in uno stato non specificato ma comunque valido.

L'oggetto value_type di un contenitore è un typedef che appartiene al contenitore e per map multimap<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 dell'intervallo (5) inserisce la sequenza di valori di elemento in un multimap oggetto che corrisponde a ogni elemento indirizzato da un iteratore nell'intervallo [First, Last), pertanto Last non viene inserito. 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.

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 multimap::emplace e multimap::emplace_hint.

Esempio

// multimap_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
    multimap<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
    m1.insert(make_pair(1, 111));

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

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

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

`multimap::iterator`

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

typedef implementation-defined iterator;

Osservazioni:

Oggetto iterator definito da multimap punta a oggetti di value_type, che sono di tipo pair<const Key, Type>. Il valore della chiave è disponibile tramite il primo membro della coppia e il valore dell'elemento mappato è disponibile tramite il secondo membro della coppia.

Per dereferenziare un iteratorIter elemento che punta a un elemento in un multimap, 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.

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

Esempio

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

`multimap::key_comp`

Recupera una copia dell'oggetto di confronto utilizzato per ordinare le chiavi di un multimap.

key_compare key_comp() const;

Valore restituito

Restituisce l'oggetto funzione utilizzato da un multimap oggetto per ordinare i relativi elementi.

Osservazioni:

L'oggetto archiviato definisce la funzione membro

bool operator( const Key& x, const Key& y);

che restituisce true se x precede y rigorosamente nell'ordinamento.

Esempio

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

int main( )
{
   using namespace std;

   multimap <int, int, less<int> > m1;
   multimap <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;
   }

   multimap <int, int, greater<int> > m2;
   multimap <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.

`multimap::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 multimap.

typedef Traits key_compare;

Osservazioni:

key_compare è un sinonimo per il parametro di modello Traits.

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

Esempio

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

`multimap::key_type`

Tipo che descrive l'oggetto chiave di ordinamento di cui è costituito ogni elemento del multimap.

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 multimap Classe .

Esempio

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

`multimap::lower_bound`

Restituisce un iteratore al primo elemento di un multimap con una chiave uguale o maggiore di una chiave specificata.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parametri

key
Chiave dell'argomento multimap da confrontare con la chiave di ordinamento di un elemento dalla ricerca.

Valore restituito

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

Se il valore restituito di lower_bound viene assegnato a un const_iteratoroggetto , l'oggetto multimap non può essere modificato. Se il valore restituito di lower_bound viene assegnato a un iteratore, l'oggetto multimap può essere modificato.

Esempio

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

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <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, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

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

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

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

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

   // The element at a specific location in the multimap 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 first element of m1 with a key matching\n"
        << "that of the last element is: "
        << m1_RcIter -> second << "." << endl;

   // Note that the first element with a key equal to
   // the key of the last element is not the last element
   if ( m1_RcIter == --m1.end( ) )
      cout << "This is the last element of multimap m1."
           << endl;
   else
      cout << "This is not the last element of multimap m1."
           << endl;
}

The element of multimap m1 with a key of 2 is: 20.
The first element of multimap m1 with a key of 3 is: 20.
The multimap m1 doesn't have an element with a key of 4.
The first element of m1 with a key matching
that of the last element is: 20.
This is not the last element of multimap m1.

`multimap::mapped_type`

Tipo che rappresenta il tipo di dati archiviati in un multimap.

typedef Type mapped_type;

Osservazioni:

mapped_type è un sinonimo per il parametro di modello Type.

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

Esempio

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

`multimap::max_size`

Restituisce la lunghezza massima del multimap.

size_type max_size() const;

Valore restituito

Lunghezza massima possibile dell'oggetto multimap.

Esempio

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

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

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

`multimap::multimap`

Costruisce un multimap vuoto o che rappresenta una copia totale o parziale di un altro multimap.

multimap();

explicit multimap(
    const Traits& Comp);

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

map(
    const multimap& Right);

multimap(
    multimap&& Right);

multimap(
    initializer_list<value_type> IList);

multimap(
    initializer_list<value_type> IList,
    const Compare& Comp);

multimap(
    initializer_list<value_type> IList,
    const Compare& Comp,
    const Allocator& Al);

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

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

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

Parametri

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

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

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
initializer_list da cui copiare gli elementi.

Osservazioni:

Tutti i costruttori archiviano un tipo di oggetto allocatore che gestisce l'archiviazione multimap di memoria per e che in un secondo momento può essere restituito 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 multimapoggetto .

Tutti i costruttori archiviano un oggetto funzione di tipo Traits utilizzato per stabilire un ordine tra le chiavi di multimap e che possono essere restituiti in un secondo momento chiamando key_comp.

I primi tre costruttori specificano un oggetto iniziale multimapvuoto, il secondo che specifica il tipo di funzione di confronto (Comp) da usare per stabilire l'ordine degli elementi e il terzo 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 multimapRight.

Il quinto costruttore specifica una copia dell'oggetto multimap spostando Right.

Il 6°, il 7 e l'8° costruttore copiano i membri di un oggetto initializer_list.

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

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

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

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

    // Create an empty multimap m1 with the key comparison
    // function of less than, then insert 4 elements
    multimap <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 multimap m2 with the key comparison
    // function of greater than, then insert 2 elements
    multimap <int, int, less<int> > m2;
    m2.insert(Int_Pair(1, 10));
    m2.insert(Int_Pair(2, 20));

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

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

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

    // Create a multimap m6 by copying the range m4[ first,  last)
    // and with the allocator of multimap m2
    multimap <int, int>::allocator_type m2_Alloc;
    m2_Alloc = m2.get_allocator();
    multimap <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 multimap m8 by copying in an initializer_list
    multimap<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 multimap m9 with an initializer_list and a comparator
    multimap<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 multimap m10 with an initializer_list, a comparator, and an allocator
    multimap<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;

}

`multimap::operator=`

Sostituisce gli elementi di un multimap con una copia di un altro multimap.

multimap& operator=(const multimap& right);

multimap& operator=(multimap&& right);

Parametri

right
Oggetto multimap copiato in multimap.

Osservazioni:

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

Esempio

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

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

`multimap::pointer`

Tipo che fornisce un puntatore a un elemento in un multimap.

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 multimap oggetto .

`multimap::rbegin`

Restituisce un iteratore che punta al primo elemento di un multimap invertito.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valore restituito

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

Osservazioni:

rbegin viene usato con un oggetto invertito multimap esattamente come begin viene usato con un oggetto multimap.

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

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

Esempio

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

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

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: reverse_iterator m1_rIter;
   multimap <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 multimap m1 is "
        << m1_rIter -> first << "." << endl;

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

   // A multimap element can be erased by dereferencing 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 multimap is "
        << m1_rIter -> first << "." << endl;
}

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

`multimap::reference`

Tipo che fornisce un riferimento a un elemento archiviato in un multimap.

typedef typename allocator_type::reference reference;

Esempio

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

int main( )
{
   using namespace std;
   multimap <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 multimap 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 multimap 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 multimap is 1.
The data value of first element in the multimap is 10.
The modified data value of first element is 15.

`multimap::rend`

Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un multimap 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 invertito (la posizione che aveva preceduto multimap il primo elemento nell'oggetto non invertito multimap).

Osservazioni:

rend viene usato con un oggetto invertito multimap esattamente come end viene usato con un oggetto multimap.

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

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

Il valore restituito da rend non deve essere dereferenziato.

Esempio

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

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

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: reverse_iterator m1_rIter;
   multimap <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 multimap m1 is "
        << m1_rIter -> first << "." << endl;

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

   // A multimap 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 multimap is "
        << m1_rIter -> first << "." << endl;
}

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

`multimap::reverse_iterator`

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

typedef std::reverse_iterator<iterator> reverse_iterator;

Osservazioni:

Un tipo reverse_iterator viene usato per scorrere l'oggetto multimap inverso.

Oggetto reverse_iterator definito da multimap punta a oggetti di value_type, che sono di tipo pair<const Key, Type>. Il valore della chiave è disponibile tramite il primo membro della coppia e il valore dell'elemento mappato è disponibile tramite il secondo membro della coppia.

Per dereferenziare un reverse_iteratorrIter elemento in un multimapoggetto , 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).second.

Esempio

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

`multimap::size`

Restituisce il numero di elementi nel multimap.

size_type size() const;

Valore restituito

Lunghezza corrente dell'oggetto multimap.

Esempio

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

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

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

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

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

The multimap length is 1.
The multimap length is now 2.

`multimap::size_type`

Tipo integer senza segno che conta il numero di elementi in un oggetto multimap.

typedef typename allocator_type::size_type size_type;

Esempio

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

`multimap::swap`

Scambia gli elementi di due multimap.

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

Parametri

right
Oggetto multimap che fornisce gli elementi da scambiare o i multimap cui elementi devono essere scambiati con quelli dell'oggetto multimapleft.

Osservazioni:

La funzione membro non invalida riferimenti, puntatori o iteratori che designano gli elementi nei due multimapelementi i cui elementi vengono scambiati.

Esempio

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

int main( )
{
   using namespace std;
   multimap <int, int> m1, m2, m3;
   multimap <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 multimap 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
   m1.swap( m2 );

   cout << "After swapping with m2, multimap 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, multimap m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;
}

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

`multimap::upper_bound`

Restituisce un iterator oggetto al primo elemento di un multimap oggetto con una chiave maggiore di una chiave specificata.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parametri

key
Chiave dell'argomento multimap da confrontare con la chiave di ordinamento di un elemento dalla ricerca.

Valore restituito

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

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

Esempio

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

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <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.insert ( Int_Pair ( 3, 40 ) );

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

   m1_RcIter = m1.upper_bound( 2 );
   cout << "The first element of multimap 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.lower_bound( 4 );

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

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

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

`multimap::value_comp`

La funzione membro restituisce un oggetto funzione che determina l'ordine degli elementi in un multimap confrontando i valori delle relative chiavi.

value_compare value_comp() const;

Valore restituito

Restituisce l'oggetto funzione di confronto utilizzato da un multimap oggetto per ordinare i relativi elementi.

Osservazioni:

Per un multimapmoggetto , se due elementi e1(k1, d1) e e2(k2, d2) sono oggetti di tipo value_type, dove k1 e k2 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).

Esempio

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

int main( )
{
   using namespace std;

   multimap <int, int, less<int> > m1;
   multimap <int, int, less<int> >::value_compare vc1 = m1.value_comp( );
   multimap<int,int>::iterator Iter1, Iter2;

   Iter1= m1.insert ( multimap <int, int> :: value_type ( 1, 10 ) );
   Iter2= m1.insert ( multimap <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *Iter1, *Iter2 ) == 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( *Iter2, *Iter1 ) == 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 ).

`multimap::value_type`

Tipo che rappresenta il tipo di oggetto archiviato come elemento di un oggetto map.

typedef pair<const Key, Type> value_type;

Esempio

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

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

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

   // Compare another way to insert objects into a hash_multimap
   m1.insert ( cInt2Int ( 2, 20 ) );

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

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

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

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

   cout  << "The keys of the mapped elements are:";
   for ( pIter = 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;
}

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

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++

Share via

Classe multimap

Sintassi

Parametri

Osservazioni:

Membri

Costruttori

Typedef

Funzioni membro

Requisiti

multimap::allocator_type

Esempio

multimap::begin

Valore restituito

Esempio

multimap::cbegin

Valore restituito

Osservazioni:

multimap::cend

Valore restituito

Osservazioni:

multimap::clear

Esempio

multimap::const_iterator

Osservazioni:

Esempio

multimap::const_pointer

Osservazioni:

multimap::const_reference

Esempio

multimap::const_reverse_iterator

Osservazioni:

Esempio

multimap::contains

Parametri

Valore restituito

Osservazioni:

Esempio

multimap::count

Parametri

Valore restituito

Osservazioni:

Esempio

multimap::crbegin

Valore restituito

Osservazioni:

Esempio

multimap::crend

Valore restituito

Osservazioni:

Esempio

multimap::difference_type

Osservazioni:

Esempio

multimap::emplace

Parametri

Valore restituito

Osservazioni:

Esempio

multimap::emplace_hint

Parametri

Valore restituito

Osservazioni:

multimap::empty

Valore restituito

Esempio

multimap::end

Valore restituito

Osservazioni:

multimap::equal_range

Parametri

Valore restituito

Esempio

multimap::erase

Parametri

Valore restituito

Osservazioni:

multimap::find

Parametri

Valore restituito

Classe `multimap`

`multimap::allocator_type`

`multimap::begin`

`multimap::cbegin`

`multimap::cend`

`multimap::clear`

`multimap::const_iterator`

`multimap::const_pointer`

`multimap::const_reference`

`multimap::const_reverse_iterator`

`multimap::contains`

`multimap::count`

`multimap::crbegin`

`multimap::crend`

`multimap::difference_type`

`multimap::emplace`

`multimap::emplace_hint`

`multimap::empty`

`multimap::end`

`multimap::equal_range`

`multimap::erase`

`multimap::find`

`multimap::get_allocator`

`multimap::insert`

`multimap::iterator`

`multimap::key_comp`

`multimap::key_compare`

`multimap::key_type`

`multimap::lower_bound`

`multimap::mapped_type`

`multimap::max_size`

`multimap::multimap`

`multimap::operator=`

`multimap::pointer`

`multimap::rbegin`

`multimap::reference`

`multimap::rend`

`multimap::reverse_iterator`

`multimap::size`

`multimap::size_type`

`multimap::swap`

`multimap::upper_bound`