map::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
Parametro |
Descrizione |
Val |
Valore di un elemento da inserire nella mappa a meno che non vi sia già contenuto 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 di modello che specifica il tipo di argomenti che può essere usato dalla mappa per costruire un elemento di value_type e che esegue l'inoltro perfetto di Val come argomento. |
First |
Posizione del primo elemento da copiare. |
Last |
Posizione immediatamente dopo l'ultimo elemento da copiare. |
InputIterator |
Argomento della funzione di modello che soddisfa i requisiti di un iteratore di input che fa riferimento agli elementi di un tipo che possono essere usati per costruire oggetti value_type. |
IList |
Oggetto initializer_list da cui copiare gli elementi. |
Valore restituito
Le funzioni membro a elemento singolo (1) e (2) restituiscono una coppia il cui componente bool è true se è stato eseguito 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.
Note
Non ci sono iteratori, puntatori o riferimenti invalidati da questa funzione.
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.
Per accedere al componente dell'iteratore di una pair pr restituita dalle funzioni membro a elemento singolo, 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.
Il value_type di un contenitore è un typedef appartenente al contenitore e per la mappa 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 di elenco dell'inizializzatore (6) usa un initializer_list per copiare gli elementi nella mappa.
Per l'inserimento di un elemento creato sul posto, ovvero senza esecuzione di 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;
}
Output
The original key and mapped values of m1 are:
2 elements: (1, 10) (2, 20)
Insert failed, element with key value 1 already exists.
The existing element is (1, 10)
The modified key and mapped values of m1 are:
3 elements: (1, 10) (2, 20) (3, 30)
Inserting the following vector data into m2:
5 elements: (43, 294) (41, 262) (45, 330) (42, 277) (44, 311)
The modified key and mapped values of m2 are:
5 elements: (41, 262) (42, 277) (43, 294) (44, 311) (45, 330)
After the first move insertion, m3 contains:
1 elements: (475, blue)
After the second move insertion, m3 contains:
2 elements: (475, blue) (510, green)
After initializer_list insertion, m4 contains:
5 elements: (1, 11) (2, 22) (3, 33) (4, 44) (5, 55)
Requisiti
Intestazione: <map>
Spazio dei nomi: std