unordered_multiset::unordered_multiset

Erstellt ein container-Objekt.

unordered_multiset(
    const unordered_multiset& Right
);
explicit unordered_multiset(
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc()
);
unordered_multiset(
    unordered_multiset&& Right
);
unordered_set(
    initializer_list<Type> IList
);
unordered_set(
    initializer_list<Typ > IList,
    size_type Bucket_count
);
unordered_set(
    initializer_list<Type> IList, 
    size_type Bucket_count, 
    const Hash& Hash
); 
unordered_set(
    initializer_list<Type> IList, 
    size_type Bucket_count, 
    const Hash& Hash, 
    const Key& Key
);
unordered_set(
    initializer_list<Type> IList, 
    size_type Bucket_count, 
    const Hash& Hash, 
    const Key& Key, 
    const Allocator& Al
);
template<class InputIterator>
    unordered_multiset(
        InputIterator First, 
        InputIterator Last,
        size_type Bucket_count = N0,
        const Hash& Hash = Hash(),
        const Comp& Comp = Comp(),
        const Allocator& Al = Alloc()
    );

Parameter

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 durch die Implementierung definierte 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 Comp().

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

Beispiel 

Code

/ std_tr1__unordered_set__unordered_multiset_construct.cpp 
// compile with: /EHsc 
#include <unordered_set> 
#include <iostream> 

using namespace std;

typedef unordered_multiset<char> Myset;

int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents " [c] [b] [a]" 
    for (auto& c : c1) {
        cout << " [" << c << "]";
    }
    cout << endl;

    Myset c2(8,
        hash<char>(),
        equal_to<char>(),
        allocator<pair<const char, int> >());

    c2.insert('d');
    c2.insert('e');
    c2.insert('f');

    // display contents " [f] [e] [d]" 
    for (auto& c : c2) {
        cout << " [" << c << "]";
    }
    cout << endl;

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

    // display contents " [c] [b] [a]" 
    for (auto& c : c3) {
        cout << " [" << c << "]";
    }
    cout << endl;

    Myset c4(move(c3));

    // display contents " [c] [b] [a]" 
    for (auto& c : c4) {
        cout << " [" << c << "]";
    }
    cout << endl;

    Myset c5{ { 'g', 'h' } };
    for (auto& c : c5) {
        cout << " [" << c << "]";
    }
    cout << endl;
}
// std_tr1__unordered_set__unordered_multiset_construct.cpp 
// compile with: /EHsc 
#include <unordered_set> 
#include <iostream> 
 
typedef std::unordered_multiset<char> Myset; 
int main() 
    { 
    Myset c1; 
 
    c1.insert('a'); 
    c1.insert('b'); 
    c1.insert('c'); 
 
// display contents " [c] [b] [a]" 
    for (Myset::const_iterator it = c1.begin(); 
        it != c1.end(); ++it) 
        std::cout << " [" << *it << "]"; 
    std::cout << std::endl; 
 
    Myset c2(8, 
        std::hash<char>(), 
        std::equal_to<char>(), 
        std::allocator<std::pair<const char, int> >()); 
 
    c2.insert('d'); 
    c2.insert('e'); 
    c2.insert('f'); 
 
// display contents " [f] [e] [d]" 
    for (Myset::const_iterator it = c2.begin(); 
        it != c2.end(); ++it) 
        std::cout << " [" << *it << "]"; 
    std::cout << std::endl; 
 
    Myset c3(c1.begin(), 
        c1.end(), 
        8, 
        std::hash<char>(), 
        std::equal_to<char>(), 
        std::allocator<std::pair<const char, int> >()); 
 
// display contents " [c] [b] [a]" 
    for (Myset::const_iterator it = c3.begin(); 
        it != c3.end(); ++it) 
        std::cout << " [" << *it << "]"; 
    std::cout << std::endl; 
 
    Myset c4(std::move(c3));

// display contents " [c] [b] [a]" 
    for (Myset::const_iterator it = c3.begin(); 
        it != c3.end(); ++it) 
        std::cout << " [" << *it << "]"; 
    std::cout << std::endl; 

    return (0); 
    } 
 

Ausgabe

[a] [b] [c]
 [d] [e] [f]
 [a] [b] [c]
 [a] [b] [c]
 [g] [h]

Anforderungen

Header: <unordered_set>

Namespace: std

Siehe auch

Referenz

<unordered_set>

unordered_multiset-Klasse

Weitere Ressourcen

<unordered_set> Member