unordered_map::unordered_map

Construye un objeto contenedor.

unordered_map(
    const unordered_map& Right
);
explicit unordered_map(
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Allocator()
);
unordered_map(
    unordered_map&& Right
);
unordered_map(
    initializer_list<Type> IList
);
unordered_map(
    initializer_list<Type> IList, 
    size_type Bucket_count
);
unordered_map(
    initializer_list<Type> IList, 
    size_type Bucket_count, 
    const Hash& Hash
);
unordered_map(
    initializer_list<Type> IList, 
    size_type Bucket_count, 
    const Hash&  Hash,
    KeyEqual& equal
);
unordered_map(
    initializer_list<Type> IList, 
    size_type Bucket_count,
    const Hash&  Hash,
    KeyEqual& Equal
    const Allocator& Al
);
template<class InIt>
    unordered_map(
        InputIterator First, 
        InputIterator Last,
        size_type Bucket_count = N0,
        const Hash& Hash = Hash(),
        const Comp& Comp = Comp(),
        const Allocator& Al = Alloc()
    );

Parámetros

Parámetro	Descripción
Al	Objeto de asignador que se va a almacenar.
Comp	Objeto de función de comparación que se va a almacenar.
Hash	Objeto de función hash que se va a almacenar.
Bucket_count	Número mínimo de depósitos.
Right	Contenedor que se va a copiar.
First
Last
IList	initializer_list que contiene los elementos que se van a copiar.

Comentarios

El primer constructor especifica una copia de la secuencia controlada por right. El segundo constructor especifica una secuencia controlada vacía. El tercer constructor inserta la secuencia de valores de elemento [first, last). El cuarto constructor especifica una copia de la secuencia moviendo right.

Todos los constructores también inicializan varios valores almacenados. Para el constructor de copias, los valores se obtienen de Right. De lo contrario:

el número mínimo de depósitos es el argumento Bucket_count, si está presente; de lo contrario, es un valor predeterminado descrito aquí como el valor N0 definido por la implementación.

el objeto de función hash es el argumento Hash, si está presente; de lo contrario, es Hash().

El objeto de función de comparación es el argumento Comp, si está presente; de lo contrario, es Pred().

El objeto de asignador es el argumento Al, si está presente; de lo contrario, es Alloc().

Ejemplo

 

// std__unordered_map__unordered_map_construct.cpp 
// compile with: /EHsc 
#include <unordered_map> 
#include <iostream> 
#include <initializer_list>

using namespace std;

using Mymap = unordered_map<char, int>;

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

    // display contents " [c 3] [b 2] [a 1]" 
    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    Mymap c2(8,
        tr1::hash<char>(),
        equal_to<char>(),
        allocator<pair<const char, int> >());

    c2.insert(Mymap::value_type('d', 4));
    c2.insert(Mymap::value_type('e', 5));
    c2.insert(Mymap::value_type('f', 6));

    // display contents " [f 6] [e 5] [d 4]" 
    for (const auto& c : c2) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    Mymap c3(c1.begin(),
        c1.end(),
        8,
        tr1::hash<char>(),
        equal_to<char>(),
        allocator<pair<const char, int> >());

    // display contents " [c 3] [b 2] [a 1]" 
    for (const auto& c : c3) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    Mymap c4(move(c3));

    // display contents " [c 3] [b 2] [a 1]" 
    for (const auto& c : c4) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;
    cout << endl;

    // Construct with an initializer_list
    unordered_map<int, char> c5({ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } });
    for (const auto& c : c5) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size
    unordered_map<int, char> c6({ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } }, 4);
    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;
    cout << endl;

    // Initializer_list plus size and hash
    unordered_map<int, char, tr1::hash<char>> c7(
        { { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } }, 
        4, 
        tr1::hash<char>()
    );
   
    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size, hash, and key_equal
    unordered_map<int, char, tr1::hash<char>, equal_to<char>> c8(
        { { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } }, 
        4, 
        tr1::hash<char>(), 
        equal_to<char>()
    );
    
    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size, hash, key_equal, and allocator
    unordered_map<int, char, tr1::hash<char>, equal_to<char>> c9(
        { { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
        4,
        tr1::hash<char>(),
        equal_to<char>(),
        allocator<pair<const char, int> >()
    );
    
    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;
}

Requisitos

Encabezado: <unordered_map>

Espacio de nombres: std

Vea también

Referencia

<unordered_map>

unordered_map (Clase)

Otros recursos

miembros de <unordered_map>