unordered_map::unordered_map

Erstellt ein container-Objekt.

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

Parameter

Parameter	Beschreibung
Al	Das zu speichernde Zuweisungsobjekt.
Comp	Das zu speichernde Vergleichsfunktionsobjekt.
Hash	Das zu speichernde Hashfunktionsobjekt.
Bucket_count	Die Mindestanzahl von Buckets.
Right	Der zu kopierende Container.
First
Last
IList	Das initializer_list-Element, das die zu kopierenden Elemente enthält.

Hinweise

Mit dem ersten Konstruktor wird eine Kopie der Sequenz angegeben, die von right gesteuert wird. Mit dem zweiten Konstruktor wird eine leere gesteuerte Sequenz angegeben. Mit dem dritten Konstruktor wird die Elementwertesequenz [first, last) eingefügt. Mit dem vierten Konstruktor wird eine Kopie der Sequenz angegeben, indem right verschoben wird.

Alle Konstruktoren initialisieren auch einige gespeicherte Werte. Für den Kopierkonstruktor werden die Werte aus Right abgerufen. Andernfalls gilt:

die Mindestbucketanzahl entspricht dem Argument Bucket_count, falls es vorhanden ist. Andernfalls ist es ein Standardwert, der hier als der implementierungsdefinierte Wert N0 beschrieben wird.

das Hashfunktionsobjekt ist das Argument Hash, falls es vorhanden ist. Andernfalls ist es Hash().

Das Vergleichfunktionsobjekt ist das Argument Comp, falls es vorhanden ist. Andernfalls ist es Pred().

Das Zuweisungsobjekt ist das Argument Al, falls es vorhanden ist. Andernfalls ist es Alloc().

Beispiel

 

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

Anforderungen

Header: <unordered_map>

Namespace: std

Siehe auch

Referenz

<unordered_map>

unordered_map-Klasse

Weitere Ressourcen

<unordered_map> Member