map::map
Costruisce una map vuoto o che è una copia totale o parziale di qualche altra 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
Parametro |
Descrizione |
Al |
La classe dell'allocatore di memoria da utilizzare per questo oggetto map, che per impostazione predefinita corrisponde ad Allocator. |
Comp |
La funzione di confronto di tipo const Traits utilizzata per ordinare gli elementi nella map, che per impostazione predefinita corrisponde a hash_compare. |
Right |
La mappa di cui l'insieme costruito deve essere una copia. |
First |
Posizione del primo elemento nella serie di elementi da copiare. |
Last |
Posizione del primo elemento oltre la serie di elementi da copiare. |
IList |
La initializer_list da cui gli elementi devono essere copiati. |
Note
Tutti i costruttori memorizzano un tipo di oggetto allocatore che gestisce l'archiviazione in memoria per la map e che successivamente può essere restituito chiamando get_allocator. Il parametro di allocazione viene spesso omesso nelle dichiarazioni di classe e nelle macro del preprocessore utilizzate per sostituire allocatori alternativi.
Tutti i costruttori inizializzano le proprie map.
Tutti i costruttori archiviano un oggetto funzione di tipo Traits utilizzato per stabilire un ordine tra le chiavi della map e che successivamente possono essere restituite chiamando key_comp.
I primi tre costruttori specificano una map iniziale vuota, il secondo specifica il tipo di funzione di confronto (Comp) da utilizzare per stabilire l'ordine degli elementi e il terzo specifica in modo esplicito il tipo di allocatore (Al) da utilizzare. La parola chiave explicit elimina determinati tipi di conversione automatica dei tipi.
Il quarto costruttore specifica una copia della map Right.
Il quinto costruttore specifica una copia della map spostando Right.
Il sesto, il settimo e l'ottavo costruttore usano una initializer_list da cui copiare i membri.
I tre costruttori seguenti copiano l'intervallo [First, Last) di una map con più chiarezza esplicita nello specificare il tipo di funzione di confronto di classe Traits e 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 geater 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;
}
Output
m1 = 10 20 30 40
m2 = 10 20
m3 = 30
m4 = 10 20 30 40
m5 = 10 20
m6 = 10
m7 = 10 20
m8: = 1 1, 2 2, 3 3, 4 4,
m9: = 5 5, 6 6, 7 7, 8 8,
m10: = 9 9, 10 10, 11 11, 12 12,
Requisiti
Intestazione: <map>
Spazio dei nomi: std