unordered_multimap::unordered_multimap

Construit un objet conteneur.

unordered_multimap(
    const unordered_multimap& Right
);
explicit unordered_multimap(
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Pred(),
    const Allocator& Al = Alloc()
);
unordered_multimap(
    unordered_multimap&& Right
);
unordered_multimap(
    initializer_list<Type> IList
);
unordered_multimap(
    initializer_list< Type > IList,
    size_type Bucket_count
);
unordered_multimap(
    initializer_list< Type > IList,
    size_type Bucket_count, 
    const Hash& Hash
);
unordered_multimap(
    initializer_list< Type > IList,
    size_type Bucket_count, 
    const Hash& Hash,
    const Key& Key
);
unordered_multimap(
    initializer_list<Type> IList,
    size_type Bucket_count, 
    const Hash& Hash,
    const Key& Key, 
    const Allocator& Al
);
template<class InputIterator>
    unordered_multimap(
        InputIterator first, 
        InputIterator last,
        size_type Bucket_count = N0,
        const Hash& Hash = Hash(),
        const Comp& Comp = Pred(),
        const Allocator& Al = Alloc()
    );

Paramètres

Paramètre	Description
InputIterator	Type d'itérateur.
Al	Objet allocateur à stocker.
Comp	Objet de fonction de comparaison à stocker.
Hash	Objet de fonction de hachage à stocker.
Bucket_count	Nombre minimal de compartiments.
Right	Conteneur à copier.
IList	Initializer_list depuis laquelle copier les éléments.

Notes

Le premier constructeur spécifie une copie de la séquence contrôlée par Right. Le deuxième constructeur spécifie une séquence vide contrôlée. Le troisième constructeur spécifie une copie de la séquence en déplaçant Right. Le quatrième, le cinquième, le sixième, le septième et le huitième constructeurs utilisent une initializer_list pour les membres. Le neuvième constructeur insère la séquence de valeurs d'éléments [First, Last).

Tous les constructeurs initialisent également plusieurs valeurs stockées. Pour le constructeur de copie, les valeurs sont obtenues à partir de Right. Sinon :

Le nombre minimal de compartiments est l'argument Bucket_count, s'il existe ; sinon c'est une valeur par défaut décrite ici comme valeur N0 définie par l'implémentation.

L'objet de fonction de hachage est l'argument Hash, s'il existe ; sinon c'est Hash().

L'objet de fonction de comparaison est l'argument Comp, s'il existe ; sinon c'est Pred().

L'objet allocateur est l'argument Al, s'il existe ; sinon, c'est Alloc().

Exemple

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

using namespace std;

using  Mymap = unordered_multimap<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,
        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,
        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;

    // Construct with an initializer_list
    unordered_multimap<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_multimap<int, char> c6({ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } }, 4);
    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size and hash
    unordered_multimap<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_multimap<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_multimap<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;
}

Configuration requise

En-tête : <unordered_map>

Espace de noms : std

Voir aussi

Référence

<unordered_map>

unordered_multimap, classe

Autres ressources

<unordered_map> membres