unordered_multiset-Klasse
Die Klassenvorlage beschreibt ein Objekt, das eine unterschiedliche Abfolge von Elementen vom Typ const Keysteuert. Die Sequenz wird grob durch eine Hashfunktion sortiert, die die Sequenz in eine geordnete Gruppe von Untersequenzen, so genannte Buckets, unterteilt. Innerhalb jedes Buckets bestimmt eine Vergleichsfunktion, ob ein Elementpaar eine entsprechende Reihenfolge hat. Jedes Element dient sowohl als Sortierschlüssel als auch als Wert. Die Sequenz wird so dargestellt, dass die Suche, das Einfügen und das Entfernen eines beliebigen Elements mit einer Reihen von Vorgängen möglich ist, die unabhängig von der Anzahl von Elementen in der Sequenz (konstante Zeit) sein können, zumindest, wenn alle Buckets von ungefähr gleicher Länge sind. Im schlimmsten Fall, d. h., wenn sich alle Elemente in einem Bucket befinden, ist die Anzahl von Vorgängen proportional zur Anzahl von Elementen in der Sequenz (lineare Zeit). Darüber hinaus führt das Einfügen eines Elements nicht dazu, dass Iteratoren ungültig werden, und durch das Entfernen eines Elements werden nur solche Iteratoren ungültig, die auf das entfernte Element gezeigt haben.
template <class Key,
class Hash = std::hash<Key>,
class Pred = std::equal_to<Key>,
class Alloc = std::allocator<Key>>
class unordered_multiset;
Schlüssel
Der Schlüsseltyp.
Hash
Der Hashfunktionsobjekttyp.
Pred
Der Gleichheitsvergleich-Funktionsobjekttyp.
Alloc
Die Zuweisungsklasse.
| Typendefinition | Beschreibung |
|---|---|
| allocator_type | Der Typ einer Zuweisung für die Speicherverwaltung. |
| const_iterator | Der Typ eines konstanten Iterators für die gesteuerte Sequenz. |
| const_local_iterator | Der Typ eines konstanten Bucketiterators für die gesteuerte Sequenz. |
| const_pointer | Der Typ eines konstanten Zeigers auf ein Element. |
| const_reference | Der Typ eines konstanten Verweises auf ein Element. |
| difference_type | Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen. |
| Hasher | Der Typ der Hashfunktion. |
| iterator | Der Typ eines Iterators für die gesteuerte Sequenz. |
| key_equal | Der Typ der Vergleichsfunktion. |
| key_type | Der Typ eines Sortierschlüssels. |
| local_iterator | Der Typ eines Bucketiterators für die gesteuerte Sequenz. |
| pointer | Der Typ eines Zeigers auf ein Element. |
| reference | Der Typ eines Verweises auf ein Element. |
| size_type | Der Typ eines Abstands ohne Vorzeichen zwischen zwei Elementen. |
| value_type | Der Typ eines Elements. |
| Memberfunktion | Beschreibung |
|---|---|
| begin | Legt den Anfang der kontrollierten Sequenz fest. |
| Eimer | Ruft die Bucketnummer für einen Schlüsselwert ab. |
| bucket_count | Ruft die Anzahl von Buckets ab. |
| bucket_size | Ruft die Größe eines Buckets ab. |
| cbegin | Legt den Anfang der kontrollierten Sequenz fest. |
| cend | Legt das Ende der kontrollierten Sequenz fest. |
| clear | Entfernt alle Elemente. |
| enthältC++20 | Überprüft, ob ein Element mit dem angegebenen Schlüssel vorhanden ist. |
| count | Sucht die Anzahl von Elementen, die einem angegebenen Schlüssel entsprechen. |
| emplace | Fügt ein Element hinzu, das direkt erstellt wird. |
| emplace_hint | Fügt ein Element hinzu, das direkt mit Hinweis erstellt wird. |
| empty | Testet, ob keine Elemente vorhanden sind. |
| end | Legt das Ende der kontrollierten Sequenz fest. |
| equal_range | Sucht den Bereich, der einem angegebenen Schlüssel entspricht. |
| erase | Entfernt Elemente an den angegebenen Positionen. |
| find | Sucht ein Element, das einem angegebenen Schlüssel entspricht. |
| get_allocator | Ruft das gespeicherte Zuweisungsobjekt ab. |
| hash_function | Ruft das gespeicherte Hashfunktionsobjekt ab. |
| insert | Fügt Elemente hinzu. |
| key_eq | Ruft das gespeicherte Vergleichsfunktionsobjekt ab. |
| load_factor | Zählt die durchschnittliche Anzahl von Elementen pro Bucket. |
| max_bucket_count | Ruft die maximale Anzahl von Buckets ab. |
| max_load_factor | Ruft die maximale Anzahl von Elementen pro Bucket ab oder legt sie fest. |
| max_size | Ruft die maximale Größe der gesteuerten Sequenz ab. |
| Aufbereitung | Erstellt die Hashtabelle neu. |
| size | Ermittelt die Anzahl von Elementen. |
| swap | Vertauscht den Inhalt von zwei Containern. |
| unordered_multiset | Erstellt ein container-Objekt. |
| Operator | Beschreibung |
|---|---|
| unordered_multiset::operator= | Kopiert eine Hashtabelle. |
Das Objekt sortiert die Sequenz, die es steuert, indem es zwei gespeicherte Objekte aufruft, ein Vergleichsfunktionsobjekt des Typs unordered_multiset::key_equal und ein Hashfunktionsobjekt des Typs unordered_multiset::hasher. Sie greifen auf das zuerst gespeicherte Objekt zu, indem Sie die Memberfunktion unordered_multiset::key_eq() aufrufen. Auf das zweite gespeicherte Objekt greifen Sie zu, indem Sie die Memberfunktion unordered_multiset::hash_function() aufrufen. Insbesondere für alle Werte X und Y vom Typ Key gibt der Aufruf von key_eq()(X, Y) nur "true" zurück, wenn die beiden Argumentwerte die entsprechende Reihenfolge aufweisen. Der Aufruf von hash_function()(keyval) ergibt eine Verteilung von Werten des Typs size_t. Im Gegensatz zur Klassenvorlage unordered_set Klasse stellt ein Objekt vom Typ unordered_multiset nicht sicher, dass key_eq()(X, Y) für zwei Elemente der kontrollierten Sequenz immer "false" festgelegt ist. (Die Schlüssel müssen nicht eindeutig sein.)
Das Objekt speichert auch einen Höchstlastfaktor, der die maximal erwünschte durchschnittliche Anzahl von Elementen pro Bucket angibt. Wenn durch Einfügen eines Elements der Wert unordered_multiset::load_factor() den Höchstlastfaktor überschreitet, erhöht der Container die Anzahl von Buckets und erstellt die Hashtabelle nach Bedarf neu.
Die tatsächliche Reihenfolge der Elemente in der gesteuerten Sequenz hängt von der Hashfunktion, von der Vergleichsfunktion, von der Einfügereihenfolge, vom Höchstlastfaktor und von der aktuellen Anzahl von Buckets ab. Sie können die Reihenfolge der Elemente in der gesteuerten Sequenz im Allgemeinen nicht vorhersagen. Sie können allerdings sicher sein, dass jede Teilmenge von Elementen, die die entsprechende Reihenfolge aufweisen, in der gesteuerten Sequenz benachbart sind.
Das Objekt belegt Speicher und gibt Speicher für die gesteuerte Sequenz durch ein gespeichertes Zuweisungsobjekt des Typs unordered_multiset::allocator_type frei. Ein solches Allocator-Objekt muss dieselbe externe Schnittstelle wie ein Objekt vom Typ allocatoraufweisen. Beachten Sie, dass das gespeicherte Zuweisungsobjekt nicht kopiert wird, wenn das Containerobjekt zugewiesen wird.
Header:<unordered_set>
Namespace: std
Der Typ einer Zuweisung für die Speicherverwaltung.
typedef Alloc allocator_type;
Der Type stellt ein Synonym für den Vorlagenparameter Allocdar.
// std__unordered_set__unordered_multiset_allocator_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
Myset c1;
Myset::allocator_type al = c1.get_allocator();
std::cout << "al == std::allocator() is "
<< std::boolalpha << (al == Myalloc()) << std::endl;
return (0);
}
al == std::allocator() is true
Kennzeichnet den Anfang der kontrollierten Sequenz oder eines Buckets.
iterator begin();
const_iterator begin() const;
local_iterator begin(size_type nbucket);
const_local_iterator begin(size_type nbucket) const;
nbucket
Die Bucketnummer.
Die beiden ersten Memberfunktionen geben einen Vorwärtsiterator zurück, der auf das erste Element der Sequenz zeigt (bzw. unmittelbar hinter das Ende einer leeren Sequenz). Die letzten beiden Memberfunktionen geben einen Weiterleitungs iterator zurück, der auf das erste Element des Bucket-Nbucket (oder direkt über das Ende eines leeren Buckets) verweist.
// std__unordered_set__unordered_multiset_begin.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;
// inspect first two items "[c] [b]"
Myset::iterator it2 = c1.begin();
std::cout << "[" << *it2 << "] ";
++it2;
std::cout << "[" << *it2 << "] ";
std::cout << std::endl;
// inspect bucket containing 'a'
Myset::const_local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << "[" << *lit << "] ";
return (0);
}
[c] [b] [a]
[c] [b]
[a]
Ruft die Bucketnummer für einen Schlüsselwert ab.
size_type bucket(const Key& keyval) const;
keyval
Der zuzuordnende Schlüsselwert.
Die Memberfunktion gibt die Bucketnummer zurück, die derzeit dem Schlüsselwert keyvalentspricht.
// std__unordered_set__unordered_multiset_bucket.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;
// display buckets for keys
Myset::size_type bs = c1.bucket('a');
std::cout << "bucket('a') == " << bs << std::endl;
std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
<< std::endl;
return (0);
}
[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1
Ruft die Anzahl von Buckets ab.
size_type bucket_count() const;
Die Memberfunktion gibt die aktuelle Anzahl von Buckets zurück.
// std__unordered_set__unordered_multiset_bucket_count.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;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1
bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1
Ruft die Größe eines Buckets ab.
size_type bucket_size(size_type nbucket) const;
nbucket
Die Bucketnummer.
Die Memberfunktionen gibt die Größe der Bucketnummer nbucket zurück.
// std__unordered_set__unordered_multiset_bucket_size.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;
// display buckets for keys
Myset::size_type bs = c1.bucket('a');
std::cout << "bucket('a') == " << bs << std::endl;
std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
<< std::endl;
return (0);
}
[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1
Gibt einen const-Iterator zurück, mit dem das erste Element im Bereich behandelt wird.
const_iterator cbegin() const;
Ein const-Forward-Access-Iterator, der auf das erste Element des Bereichs zeigt oder die Position direkt hinter dem Ende eines leeren Bereichs (für einen leeren Bereich gilt cbegin() == cend()).
Bei dem Rückgabewert cbegin können die Elemente im Bereich nicht geändert werden.
Sie können diese Memberfunktion anstelle der begin()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. Normalerweise wird sie zusammen mit dem auto-Typableitungs-Schlüsselwort verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der begin() und cbegin() unterstützt.
auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();
// i2 is Container<T>::const_iterator
Gibt einen const-Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines Bereichs unmittelbar nachfolgt.
const_iterator cend() const;
Gibt einen const-Forward-Access-Iterator zurück, der auf eine Position unmittelbar nach dem Ende des Bereichs verweist.
cend wird verwendet, um zu testen, ob ein Iterator das Ende seines Bereichs übergeben hat.
Sie können diese Memberfunktion anstelle der end()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. Normalerweise wird sie zusammen mit dem auto-Typableitungs-Schlüsselwort verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der end() und cend() unterstützt.
auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();
// i2 is Container<T>::const_iterator
Der von cend zurückgegebene Wert darf nicht dereferenziert werden.
Entfernt alle Elemente.
void clear();
Die Memberfunktion ruft unordered_multiset::erase( unordered_multiset::begin(), unordered_multiset::end()) auf.
// std__unordered_set__unordered_multiset_clear.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;
// clear the container and reinspect
c1.clear();
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
std::cout << std::endl;
c1.insert('d');
c1.insert('e');
// display contents "[e] [d] "
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c] [b] [a]
size == 0
empty() == true
[e] [d]
size == 2
empty() == false
Der Typ eines konstanten Iterators für die gesteuerte Sequenz.
typedef T1 const_iterator;
Der Typ beschreibt ein Objekt, das als konstanter Forward-Iterator für die gesteuerte Sequenz fungieren kann. Er wird hier als Synonym für einen durch Implementierung definierten T1-Typ beschrieben.
// std__unordered_set__unordered_multiset_const_iterator.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;
return (0);
}
[c] [b] [a]
Der Typ eines konstanten Bucketiterators für die gesteuerte Sequenz.
typedef T5 const_local_iterator;
Der Typ beschreibt ein Objekt, das als konstanter Vorwärtsiterator für ein Bucket dienen kann. Er wird hier als Synonym für einen durch Implementierung definierten T5-Typ beschrieben.
// std__unordered_set__unordered_multiset_const_local_iterator.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;
// inspect bucket containing 'a'
Myset::const_local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << "[" << *lit << "] ";
return (0);
}
[c] [b] [a]
[a]
Der Typ eines konstanten Zeigers auf ein Element.
typedef Alloc::const_pointer const_pointer;
Der Typ beschreibt ein Objekt, das als konstanter Zeiger für ein Element der gesteuerten Sequenz fungieren kann.
// std__unordered_set__unordered_multiset_const_pointer.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::iterator it = c1.begin();
it != c1.end(); ++it)
{
Myset::const_pointer p = &*it;
std::cout << "[" << *p << "] ";
}
std::cout << std::endl;
return (0);
}
[c] [b] [a]
Der Typ eines konstanten Verweises auf ein Element.
typedef Alloc::const_reference const_reference;
Der Typ beschreibt ein Objekt, das als Konstantenverweis für ein Element der gesteuerten Sequenz fungieren kann.
// std__unordered_set__unordered_multiset_const_reference.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::iterator it = c1.begin();
it != c1.end(); ++it)
{
Myset::const_reference ref = *it;
std::cout << "[" << ref << "] ";
}
std::cout << std::endl;
return (0);
}
[c] [b] [a]
Überprüft, ob ein Element mit dem angegebenen Schlüssel in der unordered_multiset.
bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;
K
Der Typ des Schlüssels.
key
Der Schlüsselwert des Elements, nach dem gesucht werden soll.
true wenn das Element im Container gefunden wird; false sonst.
contains() ist neu in C++20. Geben Sie zur Verwendung die Compileroption /std:c++20 oder höher an.
template<class K> bool contains(const K& key) const nimmt nur an der Überladungsauflösung teil, wenn key_compare dies transparent ist.
// Requires /std:c++20 or /std:c++latest
#include <unordered_set>
#include <iostream>
int main()
{
std::unordered_multiset<int> theUnorderedMultiset = { 1, 2, 3 };
std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
std::cout << theUnorderedMultiset.contains(1) << '\n';
std::cout << theUnorderedMultiset.contains(4) << '\n';
return 0;
}
true
false
Sucht die Anzahl von Elementen, die einem angegebenen Schlüssel entsprechen.
size_type count(const Key& keyval) const;
keyval
Der zu suchende Schlüsselwert.
Die Memberfunktion gibt die Anzahl von Elementen zurück, die sich in dem Bereich befinden, der durch unordered_multiset::equal_range(keyval) begrenzt ist.
// std__unordered_set__unordered_multiset_count.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;
std::cout << "count('A') == " << c1.count('A') << std::endl;
std::cout << "count('b') == " << c1.count('b') << std::endl;
std::cout << "count('C') == " << c1.count('C') << std::endl;
return (0);
}
[c] [b] [a]
count('A') == 0
count('b') == 1
count('C') == 0
Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
typedef T3 difference_type;
Der Ganzzahltyp mit Vorzeichen beschreibt ein Objekt, das die Differenz zwischen den Adressen von zwei beliebigen Elementen in der gesteuerten Sequenz darstellen kann. Er wird hier als Synonym für einen durch Implementierung definierten T3-Typ beschrieben.
// std__unordered_set__unordered_multiset_difference_type.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;
// compute positive difference
Myset::difference_type diff = 0;
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
++diff;
std::cout << "end()-begin() == " << diff << std::endl;
// compute negative difference
diff = 0;
for (Myset::const_iterator it = c1.end();
it != c1.begin(); --it)
--diff;
std::cout << "begin()-end() == " << diff << std::endl;
return (0);
}
[c] [b] [a]
end()-begin() == 3
begin()-end() == -3
Es wird ein Element eingefügt, das vor Ort konstruiert wird (keine Kopieren- oder Verschiebevorgänge werden ausgeführt).
template <class... Args>
iterator emplace(Args&&... args);
args
Die weitergeleiteten Argumente zur Konstruktion eines Elements, dass in das unordered_multimap-Element eingefügt werden soll.
Ein Iterator zum neu eingefügten Element.
Von dieser Funktion werden keine Verweise auf Containerelemente für ungültig erklärt, aber möglicherweise werden alle Iteratoren für den Containers für ungültig erklärt.
Wird bei der Einfügung eine Ausnahme ausgelöst, die aber in der Hashfunktion des Containers nicht auftritt, wird der Container nicht geändert. Wenn die Ausnahme in der Hashfunktion ausgelöst wird, ist das Ergebnis nicht definiert.
Ein Codebeispiel finden Sie unter multiset::emplace.
Fügt ein Element mit einem Platzierungshinweis ein, das vor Ort erstellt wird (Es werden keine Kopier- oder Verschiebevorgänge ausgeführt).
template <class... Args>
iterator emplace_hint(
const_iterator where,
Args&&... args);
args
Die weitergeleiteten Argumente zur Konstruktion eines Elements, dass in das unordered_multimap-Element eingefügt werden soll.
where
Ein Hinweis bezüglich des Platzes, an dem mit der Suche nach dem richtigen Einfügepunkt begonnen wird.
Ein Iterator zum neu eingefügten Element.
Von dieser Funktion werden keine Verweise auf Containerelemente für ungültig erklärt, aber möglicherweise werden alle Iteratoren für den Containers für ungültig erklärt.
Wird bei der Einfügung eine Ausnahme ausgelöst, die aber in der Hashfunktion des Containers nicht auftritt, wird der Container nicht geändert. Wenn die Ausnahme in der Hashfunktion ausgelöst wird, ist das Ergebnis nicht definiert.
Ein Codebeispiel finden Sie unter set::emplace_hint.
Testet, ob keine Elemente vorhanden sind.
bool empty() const;
Die Memberfunktion gibt „true“ für eine leere gesteuerte Sequenz zurück.
// std__unordered_set__unordered_multiset_empty.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;
// clear the container and reinspect
c1.clear();
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
std::cout << std::endl;
c1.insert('d');
c1.insert('e');
// display contents "[e] [d]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c] [b] [a]
size == 0
empty() == true
[e] [d]
size == 2
empty() == false
Legt das Ende der kontrollierten Sequenz fest.
iterator end();
const_iterator end() const;
local_iterator end(size_type nbucket);
const_local_iterator end(size_type nbucket) const;
nbucket
Die Bucketnummer.
Die ersten beiden Memberfunktionen geben einen Vorwärtsiterator zurück, der direkt hinter das Ende der Sequenz verweist. Die letzten beiden Memberfunktionen geben einen Vorwärts iterator zurück, der unmittelbar über das Ende des Bucket-Nbucket zeigt.
// std__unordered_set__unordered_multiset_end.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;
// inspect last two items "[a] [b]"
Myset::iterator it2 = c1.end();
--it2;
std::cout << "[" << *it2 << "] ";
--it2;
std::cout << "[" << *it2 << "] ";
std::cout << std::endl;
// inspect bucket containing 'a'
Myset::const_local_iterator lit = c1.end(c1.bucket('a'));
--lit;
std::cout << "[" << *lit << "] ";
return (0);
}
[c] [b] [a]
[a] [b]
[a]
Sucht den Bereich, der einem angegebenen Schlüssel entspricht.
std::pair<iterator, iterator>
equal_range(const Key& keyval);
std::pair<const_iterator, const_iterator>
equal_range(const Key& keyval) const;
keyval
Der zu suchende Schlüsselwert.
Die Memberfunktion gibt ein Iteratorpaar X zurück, sodass [X.first, X.second) nur die Elemente der gesteuerten Sequenz getrennt werden, die eine gleichwertige Reihenfolge mit keyval aufweisen. Wenn keine solchen Elemente vorhanden sind, sind beide Iteratoren end().
// std__unordered_set__unordered_multiset_equal_range.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;
// display results of failed search
std::pair<Myset::iterator, Myset::iterator> pair1 =
c1.equal_range('x');
std::cout << "equal_range('x'):";
for (; pair1.first != pair1.second; ++pair1.first)
std::cout << "[" << *pair1.first << "] ";
std::cout << std::endl;
// display results of successful search
pair1 = c1.equal_range('b');
std::cout << "equal_range('b'):";
for (; pair1.first != pair1.second; ++pair1.first)
std::cout << "[" << *pair1.first << "] ";
std::cout << std::endl;
return (0);
}
[c] [b] [a]
equal_range('x'):
equal_range('b'): [b]
Es wird ein Element oder ein Bereich von Elementen in einem unordered_multiset-Element von angegebenen Speicherorten entfernt oder es werden die einem angegebenen Schlüssel entsprechenden Elemente entfernt.
iterator erase(
const_iterator Where);
iterator erase(
const_iterator First,
const_iterator Last);
size_type erase(
const key_type& Key);
Where
Die Position des zu entfernenden Elements.
First
Die Position des ersten zu entfernenden Elements.
Last
Die Position direkt hinter dem letzten zu entfernenden Element.
Schlüssel
Der Schlüsselwert der zu entfernenden Elemente.
Bei den ersten beiden Memberfunktionen ist es ein bidirektionaler Iterator, der das erste über die entfernten Elemente hinaus verbliebe Element festlegt, oder ein Element, das das Ende des unordered_multiset-Elements darstellt, wenn kein solches Element vorhanden ist.
Für die dritte Memberfunktion wird die Anzahl der aus dem unordered_multiset-Element entfernten Elemente zurück gegeben.
Ein Codebeispiel finden Sie unter set::erase.
Sucht ein Element, das einem angegebenen Schlüssel entspricht.
const_iterator find(const Key& keyval) const;
keyval
Der zu suchende Schlüsselwert.
Die Memberfunktion gibt unordered_multiset::equal_range(keyval).first zurück.
// std__unordered_set__unordered_multiset_find.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;
// try to find and fail
std::cout << "find('A') == "
<< std::boolalpha << (c1.find('A') != c1.end()) << std::endl;
// try to find and succeed
Myset::iterator it = c1.find('b');
std::cout << "find('b') == "
<< std::boolalpha << (it != c1.end())
<< ": [" << *it << "] " << std::endl;
return (0);
}
[c] [b] [a]
find('A') == false
find('b') == true: [b]
Ruft das gespeicherte Zuweisungsobjekt ab.
Alloc get_allocator() const;
Die Memberfunktion gibt das gespeicherte Zuweisungsobjekt zurück.
// std__unordered_set__unordered_multiset_get_allocator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
Myset c1;
Myset::allocator_type al = c1.get_allocator();
std::cout << "al == std::allocator() is "
<< std::boolalpha << (al == Myalloc()) << std::endl;
return (0);
}
al == std::allocator() is true
Ruft das gespeicherte Hashfunktionsobjekt ab.
Hash hash_function() const;
Die Memberfunktion gibt das gespeicherte Hashfunktionsobjekt zurück.
// std__unordered_set__unordered_multiset_hash_function.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
Myset::hasher hfn = c1.hash_function();
std::cout << "hfn('a') == " << hfn('a') << std::endl;
std::cout << "hfn('b') == " << hfn('b') << std::endl;
return (0);
}
hfn('a') == 1630279
hfn('b') == 1647086
Der Typ der Hashfunktion.
typedef Hash hasher;
Der Type stellt ein Synonym für den Vorlagenparameter Hashdar.
// std__unordered_set__unordered_multiset_hasher.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
Myset::hasher hfn = c1.hash_function();
std::cout << "hfn('a') == " << hfn('a') << std::endl;
std::cout << "hfn('b') == " << hfn('b') << std::endl;
return (0);
}
hfn('a') == 1630279
hfn('b') == 1647086
Fügt ein Element oder einen Bereich von Elementen in ein unordered_multiset-Element ein.
// (1) single element
pair<iterator, bool> insert(
const value_type& Val);
// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
ValTy&& Val);
// (3) single element with hint
iterator insert(
const_iterator Where,
const value_type& Val);
// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
const_iterator Where,
ValTy&& Val);
// (5) range
template <class InputIterator>
void insert(
InputIterator First,
InputIterator Last);
// (6) initializer list
void insert(
initializer_list<value_type>
IList);
Val
Der Wert eines in das unordered_multiset-Element einzufügenden Elements.
Where
Die Position, an dem mit der Suche nach dem richtigen Einfügepunkt begonnen wird.
ValTy
Der Vorlagenparameter, der den Argumenttyp angibt, den der unordered_multiset verwenden kann, um ein Element von value_type zu konstruieren und Val als Argument perfekt weiterzuleiten.
First
Die Position des ersten zu kopierenden Elements.
Last
Die Position direkt über den letzten zu kopierenden Elements.
InputIterator
Das Vorlagenfunktionsargument, das den Anforderungen eines Eingabeiterators erfüllt, der auf Elemente eines Typs zeigt, der zum Erstellen von value_type-Objekten verwendet werden kann.
IList
Das initializer_list-Element, aus dem die Elemente kopiert werden sollen.
Die Einzelelement-Memberfunktionen (1) und (2) geben einen Iterator an die Position zurück, an der das neue Element in das unordered_multiset-Element eingefügt wurde.
Die Einzelelement-Memberfunktionen mit Hinweis (3) und (4) geben einen Iterator zurück, der auf die Position zeigt, an der das neue Element in das unordered_multiset-Element eingefügt wurde.
Von dieser Funktion werden keine Zeiger oder Verweise für ungültig erklärt, aber möglicherweise werden alle Iteratoren für den Containers für ungültig erklärt.
Wird beim Einfügen von nur einem Element eine Ausnahme ausgelöst, die jedoch nicht in der Hashfunktion des Containers auftritt, wird der Zustand des Containers nicht geändert. Wenn die Ausnahme in der Hashfunktion ausgelöst wird, ist das Ergebnis nicht definiert. Wird beim Einfügen mehrerer Elementen eine Ausnahme ausgelöst, wird der Container in einem nicht angegebenen doch gültigen Zustand belassen.
Das value_type-Element eines Containers ist eine Typdefinition, die dem Container angehört, und bei Menge ist unordered_multiset<V>::value_type vom Typ const V.
Die Bereichsmemmfunktion (5) fügt die Abfolge von Elementwerten in eine unordered_multiset ein, die jedem Element entspricht, das von einem Iterator im Bereich [First, Last)adressiert wird. Daher wird Last nicht eingefügt. Die Containermemberfunktion end() bezieht sich auf die Position direkt hinter dem letzten Element im Container. Z. B fügt die Anweisung m.insert(v.begin(), v.end()); alle Elemente von v in m ein.
Die Memberfunktion für die Initialisiererliste (6) verwendet eine initializer_list, um Elemente in die unordered_multiset zu kopieren.
Zum Einfügen eines lokal erstellten Elements. Das heißt, es wurden keine Kopier- oder Verschiebevorgänge ausgeführt. Informationen hierzu finden Sie unter unordered_multiset::emplace und unordered_multiset::emplace_hint.
Ein Codebeispiel finden Sie unter multiset::insert.
Ein Typ, der einen konstanten Forward-Iterator bereitstellt, der Elemente in einem unordered_multiset-Element lesen kann.
typedef implementation-defined iterator;
Im Beispiel für begin wird verdeutlicht, wie ein Iterator deklariert und verwendet wird.
Ruft das gespeicherte Vergleichsfunktionsobjekt ab.
Pred key_eq() const;
Die Memberfunktion gibt das gespeicherte Vergleichsfunktionsobjekt zurück.
// std__unordered_set__unordered_multiset_key_eq.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
Myset::key_equal cmpfn = c1.key_eq();
std::cout << "cmpfn('a', 'a') == "
<< std::boolalpha << cmpfn('a', 'a') << std::endl;
std::cout << "cmpfn('a', 'b') == "
<< std::boolalpha << cmpfn('a', 'b') << std::endl;
return (0);
}
cmpfn('a', 'a') == true
cmpfn('a', 'b') == false
Der Typ der Vergleichsfunktion.
typedef Pred key_equal;
Der Type stellt ein Synonym für den Vorlagenparameter Preddar.
// std__unordered_set__unordered_multiset_key_equal.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
Myset::key_equal cmpfn = c1.key_eq();
std::cout << "cmpfn('a', 'a') == "
<< std::boolalpha << cmpfn('a', 'a') << std::endl;
std::cout << "cmpfn('a', 'b') == "
<< std::boolalpha << cmpfn('a', 'b') << std::endl;
return (0);
}
cmpfn('a', 'a') == true
cmpfn('a', 'b') == false
Der Typ eines Sortierschlüssels.
typedef Key key_type;
Der Type stellt ein Synonym für den Vorlagenparameter Keydar.
// std__unordered_set__unordered_multiset_key_type.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;
// add a value and reinspect
Myset::key_type key = 'd';
Myset::value_type val = key;
c1.insert(val);
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
return (0);
}
[c] [b] [a]
[d] [c] [b] [a]
Zählt die durchschnittliche Anzahl von Elementen pro Bucket.
float load_factor() const;
Die Memberfunktion gibt (float)unordered_multiset::size() / (float)unordered_multiset::bucket_count() zurück, also die durchschnittliche Anzahl von Elementen pro Bucket.
// std__unordered_set__unordered_multiset_load_factor.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;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
return (0);
}
Der Typ eines Bucketiterators.
typedef T4 local_iterator;
Der Typ beschreibt ein Objekt, das als ein Vorwärtsiterator für ein Bucket dienen kann. Er wird hier als Synonym für einen durch Implementierung definierten T4-Typ beschrieben.
// std__unordered_set__unordered_multiset_local_iterator.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;
// inspect bucket containing 'a'
Myset::local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << "[" << *lit << "] ";
return (0);
}
[c] [b] [a]
[a]
Ruft die maximale Anzahl von Buckets ab.
size_type max_bucket_count() const;
Die Memberfunktion gibt die maximale Anzahl von Buckets zurück, die derzeit zulässig ist.
// std__unordered_set__unordered_multiset_max_bucket_count.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;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1
bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1
Ruft die maximale Anzahl von Elementen pro Bucket ab oder legt sie fest.
float max_load_factor() const;
void max_load_factor(float factor);
Faktor
Der neue maximale Lastfaktor.
Die erste Memberfunktion gibt den gespeicherten maximalen Lastfaktor zurück. Die zweite Memberfunktion ersetzt den gespeicherten maximalen Ladefaktor durch Faktor.
// std__unordered_set__unordered_multiset_max_load_factor.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;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1
bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1
Ruft die maximale Größe der gesteuerten Sequenz ab.
size_type max_size() const;
Die Memberfunktion gibt die Länge der längsten Sequenz zurück, die das Objekt steuern kann.
// std__unordered_set__unordered_multiset_max_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
std::cout << "max_size() == " << c1.max_size() << std::endl;
return (0);
}
max_size() == 4294967295
Kopiert eine Hashtabelle.
unordered_multiset& operator=(const unordered_multiset& right);
unordered_multiset& operator=(unordered_multiset&& right);
right
Das unordered_multiset, das in das unordered_multiset kopiert wird.
Nach dem Löschen vorhandener Elemente in einer unordered_multiset, operator= entweder kopiert oder verschiebt den Inhalt von rechts in die unordered_multiset.
// unordered_multiset_operator_as.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
int main( )
{
using namespace std;
unordered_multiset<int> v1, v2, v3;
unordered_multiset<int>::iterator iter;
v1.insert(10);
cout << "v1 = " ;
for (iter = v1.begin(); iter != v1.end(); iter++)
cout << *iter << " ";
cout << endl;
v2 = v1;
cout << "v2 = ";
for (iter = v2.begin(); iter != v2.end(); iter++)
cout << *iter << " ";
cout << endl;
// move v1 into v2
v2.clear();
v2 = move(v1);
cout << "v2 = ";
for (iter = v2.begin(); iter != v2.end(); iter++)
cout << *iter << " ";
cout << endl;
}
Der Typ eines Zeigers auf ein Element.
typedef Alloc::pointer pointer;
Der Typ beschreibt ein Objekt, das als Zeiger auf ein Element der gesteuerten Sequenz fungieren kann.
// std__unordered_set__unordered_multiset_pointer.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::iterator it = c1.begin();
it != c1.end(); ++it)
{
Myset::key_type key = *it;
Myset::pointer p = &key;
std::cout << "[" << *p << "] ";
}
std::cout << std::endl;
return (0);
}
[c] [b] [a]
Der Typ eines Verweises auf ein Element.
typedef Alloc::reference reference;
Der Typ beschreibt ein Objekt, das als Verweis auf ein Element der gesteuerten Sequenz fungieren kann.
// std__unordered_set__unordered_multiset_reference.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::iterator it = c1.begin();
it != c1.end(); ++it)
{
Myset::key_type key = *it;
Myset::reference ref = key;
std::cout << "[" << ref << "] ";
}
std::cout << std::endl;
return (0);
}
[c] [b] [a]
Erstellt die Hashtabelle neu.
void rehash(size_type nbuckets);
nbuckets
Die angeforderte Anzahl von Buckets.
Die Memberfunktion ändert die Anzahl der Buckets, die mindestens nbuckets sind, und erstellt die Hashtabelle nach Bedarf neu.
// std__unordered_set__unordered_multiset_rehash.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;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 4
bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 0.1
bucket_count() == 128
load_factor() == 0.0234375
max_load_factor() == 0.1
Ermittelt die Anzahl von Elementen.
size_type size() const;
Die Memberfunktion gibt die Länge der gesteuerten Sequenz zurück.
// std__unordered_set__unordered_multiset_size.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;
// clear the container and reinspect
c1.clear();
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
std::cout << std::endl;
c1.insert('d');
c1.insert('e');
// display contents "[e] [d]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c] [b] [a]
size == 0
empty() == true
[e] [d]
size == 2
empty() == false
Der Typ eines Abstands ohne Vorzeichen zwischen zwei Elementen.
typedef T2 size_type;
Der unsignierte Ganzzahltyp beschreibt ein Objekt, das die Länge jeder kontrollierten Sequenz darstellen kann. Er wird hier als Synonym für einen durch Implementierung definierten T2-Typ beschrieben.
// std__unordered_set__unordered_multiset_size_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
Myset::size_type sz = c1.size();
std::cout << "size == " << sz << std::endl;
return (0);
}
size == 0
Vertauscht den Inhalt von zwei Containern.
void swap(unordered_multiset& right);
right
Der Container für den Tauschvorgang.
Die Memberfunktion wechselt die gesteuerten Sequenzen zwischen *this und rechts. Wenn unordered_multiset::get_allocator() == right.get_allocator() gilt, führt sie dies in einer konstanten Zeit aus, sie löst eine Ausnahme nur als Reaktion auf das Kopieren des gespeicherter Merkmalobjekts vom Typ Tr aus, und sie macht keine Verweise, Zeiger oder Iteratoren ungültig, die Elemente in den beiden kontrollierten Sequenzen bestimmen. Andernfalls führt Sie proportional zur Anzahl der Elemente in den beiden kontrollierten Sequenzen eine Reihe von Elementzuweisungen und Konstruktoraufrufe aus.
// std__unordered_set__unordered_multiset_swap.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;
c2.insert('d');
c2.insert('e');
c2.insert('f');
c1.swap(c2);
// display contents "[f] [e] [d]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
swap(c1, c2);
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
return (0);
}
[c] [b] [a]
[f] [e] [d]
[c] [b] [a]
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());
InputIterator
Der Iteratortyp.
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.
IList
Das initializer_list-Element, aus dem kopiert werden soll.
Der erste Konstruktor gibt eine Kopie der von Right gesteuerten Sequenz an. Mit dem zweiten Konstruktor wird eine leere gesteuerte Sequenz angegeben. Mit dem dritten Konstruktor wird die Elementwertesequenz [First, Last) eingefügt. Der vierte Konstruktor gibt eine Kopie der Sequenz an, indem nach rechts verschoben wird.
Alle Konstruktoren initialisieren auch einige gespeicherte Werte. Für den Kopierkonstruktor werden die Werte aus Right abgerufen. Ansonsten:
Die minimale Anzahl von Buckets ist das Argument Bucket_count, falls vorhanden. Andernfalls handelt es sich um einen hier beschriebenen Standardwert als implementierungsdefinierter Wert N0.
Das Hash-Funktionsobjekt ist das Argument Hash, falls vorhanden; andernfalls ist Hash()es .
Das Vergleichsfunktionsobjekt ist das Argument Comp, falls vorhanden; andernfalls ist Comp()es .
The allocator object is the argument Al, if present; otherwise, it is Alloc().
Der Typ eines Elements.
typedef Key value_type;
Der Typ beschreibt ein Element der gesteuerten Sequenz.
// std__unordered_set__unordered_multiset_value_type.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;
// add a value and reinspect
Myset::key_type key = 'd';
Myset::value_type val = key;
c1.insert(val);
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
return (0);
}
[c] [b] [a]
[d] [c] [b] [a]
<unordered_set>
Container
Threadsicherheit in der C++-Standardbibliothek
C++-Standardbibliotheksreferenz