unordered_multimap-Klasse
Die Klassenvorlage beschreibt ein Objekt, das eine unterschiedliche Abfolge von Elementen vom Typ std::pair<const Key, Ty>steuert. 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 speichert zwei Objekte, einen Sortierschlüssel und einen 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.
Syntax
template <class Key,
class Ty,
class Hash = std::hash<Key>,
class Pred = std::equal_to<Key>,
class Alloc = std::allocator<Key>>
class unordered_multimap;
Parameter
Schlüssel
Der Schlüsseltyp.
Ty
Der zugeordnete Typ.
Hash
Der Hashfunktionsobjekttyp.
Pred
Der Gleichheitsvergleich-Funktionsobjekttyp.
Alloc
Die Zuweisungsklasse.
Member
| 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. |
| mapped_type | Der Typ eines zugeordneten Werts, der jedem Schlüssel zugeordnet ist. |
| 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 in der unordered_multimap. |
| 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_multimap | Erstellt ein container-Objekt. |
| Operator | Beschreibung |
|---|---|
| unordered_multimap::operator= | Kopiert eine Hashtabelle. |
Hinweise
Das Objekt sortiert die Sequenz, die es steuert, indem es zwei gespeicherte Objekte aufruft, ein Vergleichsfunktionsobjekt des Typs unordered_multimap::key_equal und ein Hashfunktionsobjekt des Typs unordered_multimap::hasher. Sie greifen auf das zuerst gespeicherte Objekt zu, indem Sie die Memberfunktion unordered_multimap::key_eq() aufrufen. Auf das zweite gespeicherte Objekt greifen Sie zu, indem Sie die Memberfunktion unordered_multimap::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_map Klasse stellt ein Typobjekt unordered_multimap 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_multimap::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_multimap::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.
Anforderungen
Header:<unordered_map>
Namespace: std
unordered_multimap::allocator_type
Der Typ einer Zuweisung für die Speicherverwaltung.
typedef Alloc allocator_type;
Hinweise
Der Type stellt ein Synonym für den Vorlagenparameter Allocdar.
Beispiel
// std__unordered_map__unordered_multimap_allocator_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
Mymap c1;
Mymap::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
unordered_multimap::begin
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;
Parameter
nbucket
Die Bucketnummer.
Hinweise
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.
Beispiel
// std__unordered_map__unordered_multimap_begin.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect first two items " [c 3] [b 2]"
Mymap::iterator it2 = c1.begin();
std::cout << " [" << it2->first << ", " << it2->second << "]";
++it2;
std::cout << " [" << it2->first << ", " << it2->second << "]";
std::cout << std::endl;
// inspect bucket containing 'a'
Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << " [" << lit->first << ", " << lit->second << "]";
return (0);
}
[c, 3] [b, 2] [a, 1]
[c, 3] [b, 2]
[a, 1]
unordered_multimap::bucket
Ruft die Bucketnummer für einen Schlüsselwert ab.
size_type bucket(const Key& keyval) const;
Parameter
keyval
Der zuzuordnende Schlüsselwert.
Hinweise
Die Memberfunktion gibt die Bucketnummer zurück, die derzeit dem Schlüsselwert keyval entspricht.
Beispiel
// std__unordered_map__unordered_multimap_bucket.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// display buckets for keys
Mymap::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, 3] [b, 2] [a, 1]
bucket('a') == 7
bucket_size(7) == 1
unordered_multimap::bucket_count
Ruft die Anzahl von Buckets ab.
size_type bucket_count() const;
Hinweise
Die Memberfunktion gibt die aktuelle Anzahl von Buckets zurück.
Beispiel
// std__unordered_map__unordered_multimap_bucket_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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, 3] [b, 2] [a, 1]
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
unordered_multimap::bucket_size
Ruft die Größe eines Buckets ab.
size_type bucket_size(size_type nbucket) const;
Parameter
nbucket
Die Bucketnummer.
Hinweise
Die Memberfunktionen gibt die Größe der Bucketnummer nbucket zurück.
Beispiel
// std__unordered_map__unordered_multimap_bucket_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// display buckets for keys
Mymap::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, 3] [b, 2] [a, 1]
bucket('a') == 7
bucket_size(7) == 1
unordered_multimap::cbegin
Gibt einen const-Iterator zurück, mit dem das erste Element im Bereich behandelt wird.
const_iterator cbegin() const;
Rückgabewert
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()).
Hinweise
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
unordered_multimap::cend
Gibt einen const-Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines Bereichs unmittelbar nachfolgt.
const_iterator cend() const;
Rückgabewert
Gibt einen const-Forward-Access-Iterator zurück, der auf eine Position unmittelbar nach dem Ende des Bereichs verweist.
Hinweise
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.
unordered_multimap::clear
Entfernt alle Elemente.
void clear();
Hinweise
Die Memberfunktion ruft unordered_multimap::erase( unordered_multimap::begin(), unordered_multimap::end()) auf.
Beispiel
// std__unordered_map__unordered_multimap_clear.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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(Mymap::value_type('d', 4));
c1.insert(Mymap::value_type('e', 5));
// display contents " [e 5] [d 4]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
size == 0
empty() == true
[e, 5] [d, 4]
size == 2
empty() == false
unordered_multimap::const_iterator
Der Typ eines konstanten Iterators für die gesteuerte Sequenz.
typedef T1 const_iterator;
Hinweise
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.
Beispiel
// std__unordered_map__unordered_multimap_const_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::const_local_iterator
Der Typ eines konstanten Bucketiterators für die gesteuerte Sequenz.
typedef T5 const_local_iterator;
Hinweise
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.
Beispiel
// std__unordered_map__unordered_multimap_const_local_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect bucket containing 'a'
Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << " [" << lit->first << ", " << lit->second << "]";
return (0);
}
[c, 3] [b, 2] [a, 1]
[a, 1]
unordered_multimap::const_pointer
Der Typ eines konstanten Zeigers auf ein Element.
typedef Alloc::const_pointer const_pointer;
Hinweise
Der Typ beschreibt ein Objekt, das als konstanter Zeiger für ein Element der gesteuerten Sequenz fungieren kann.
Beispiel
// std__unordered_map__unordered_multimap_const_pointer.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
{
Mymap::const_pointer p = &*it;
std::cout << " [" << p->first << ", " << p->second << "]";
}
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::const_reference
Der Typ eines konstanten Verweises auf ein Element.
typedef Alloc::const_reference const_reference;
Hinweise
Der Typ beschreibt ein Objekt, das als Konstantenverweis für ein Element der gesteuerten Sequenz fungieren kann.
Beispiel
// std__unordered_map__unordered_multimap_const_reference.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
{
Mymap::const_reference ref = *it;
std::cout << " [" << ref.first << ", " << ref.second << "]";
}
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::contains
Überprüft, ob ein Element mit dem angegebenen Schlüssel in der unordered_multimap.
bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;
Parameter
K
Der Typ des Schlüssels.
key
Der Schlüsselwert des Elements, nach dem gesucht werden soll.
Rückgabewert
true wenn das Element im Container gefunden wird; false sonst.
Hinweise
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.
Beispiel
// Requires /std:c++20 or /std:c++latest
#include <unordered_map>
#include <iostream>
int main()
{
std::unordered_multimap<int, bool> theUnorderedMultimap = {{0, false}, {1,true}};
std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
std::cout << theUnorderedMultimap.contains(1) << '\n';
std::cout << theUnorderedMultimap.contains(2) << '\n';
return 0;
}
true
false
unordered_multimap::count
Sucht die Anzahl von Elementen, die einem angegebenen Schlüssel entsprechen.
size_type count(const Key& keyval) const;
Parameter
keyval
Der zu suchende Schlüsselwert.
Hinweise
Die Memberfunktion gibt die Anzahl von Elementen zurück, die sich in dem Bereich befinden, der durch unordered_multimap::equal_range(keyval) begrenzt ist.
Beispiel
// std__unordered_map__unordered_multimap_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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, 3] [b, 2] [a, 1]
count('A') == 0
count('b') == 1
count('C') == 0
unordered_multimap::difference_type
Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
typedef T3 difference_type;
Hinweise
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.
Beispiel
// std__unordered_map__unordered_multimap_difference_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// compute positive difference
Mymap::difference_type diff = 0;
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
++diff;
std::cout << "end()-begin() == " << diff << std::endl;
// compute negative difference
diff = 0;
for (Mymap::const_iterator it = c1.end();
it != c1.begin(); --it)
--diff;
std::cout << "begin()-end() == " << diff << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
end()-begin() == 3
begin()-end() == -3
unordered_multimap::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(Args&&... args);
Parameter
args
Die Argumente, die weitergeleitet werden, um ein Element zu konstruieren, das in das unordered_multimapElement eingefügt werden soll.
Rückgabewert
Ein Iterator zum neu eingefügten Element.
Hinweise
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.
Der value_type eines Elements wird paarweise angegeben, damit der Wert eines Elements ein geordnetes Paar ist, bei dem die erste Komponente und der Schlüsselwert sowie die zweite Komponente und der Datenwert des Elements jeweils identisch sind.
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 multimap::emplace.
unordered_multimap::emplace_hint
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);
Parameter
args
Die weitergeleiteten Argumente zur Konstruktion eines Elements, dass in die unsortierte Mehrfachzuordnung eingefügt werden soll.
where
Ein Hinweis bezüglich des Platzes, an dem mit der Suche nach dem richtigen Einfügepunkt begonnen wird.
Rückgabewert
Ein Iterator zum neu eingefügten Element.
Hinweise
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.
Der value_type eines Elements wird paarweise angegeben, damit der Wert eines Elements ein geordnetes Paar ist, bei dem die erste Komponente und der Schlüsselwert sowie die zweite Komponente und der Datenwert des Elements jeweils identisch sind.
Ein Codebeispiel finden Sie unter map::emplace_hint.
unordered_multimap::empty
Testet, ob keine Elemente vorhanden sind.
bool empty() const;
Hinweise
Die Memberfunktion gibt „true“ für eine leere gesteuerte Sequenz zurück.
Beispiel
// std__unordered_map__unordered_multimap_empty.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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(Mymap::value_type('d', 4));
c1.insert(Mymap::value_type('e', 5));
// display contents " [e 5] [d 4]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
size == 0
empty() == true
[e, 5] [d, 4]
size == 2
empty() == false
unordered_multimap::end
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;
Parameter
nbucket
Die Bucketnummer.
Hinweise
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.
Beispiel
// std__unordered_map__unordered_multimap_end.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect last two items " [a 1] [b 2]"
Mymap::iterator it2 = c1.end();
--it2;
std::cout << " [" << it2->first << ", " << it2->second << "]";
--it2;
std::cout << " [" << it2->first << ", " << it2->second << "]";
std::cout << std::endl;
// inspect bucket containing 'a'
Mymap::const_local_iterator lit = c1.end(c1.bucket('a'));
--lit;
std::cout << " [" << lit->first << ", " << lit->second << "]";
return (0);
}
[c, 3] [b, 2] [a, 1]
[a, 1] [b, 2]
[a, 1]
unordered_multimap::equal_range
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;
Parameter
keyval
Der zu suchende Schlüsselwert.
Hinweise
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().
Beispiel
// std__unordered_map__unordered_multimap_equal_range.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// display results of failed search
std::pair<Mymap::iterator, Mymap::iterator> pair1 =
c1.equal_range('x');
std::cout << "equal_range('x'):";
for (; pair1.first != pair1.second; ++pair1.first)
std::cout << " [" << pair1.first->first
<< ", " << pair1.first->second << "]";
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->first
<< ", " << pair1.first->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
equal_range('x'):
equal_range('b'): [b, 2]
unordered_multimap::erase
Es wird ein Element oder ein Bereich von Elementen in einem unordered_multimap-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);
Parameter
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.
Rückgabewert
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 der Zuordnung darstellt, wenn kein solches Element vorhanden ist.
Für die dritte Memberfunktion wird die Anzahl der aus dem unordered_multimap-Element entfernten Elemente zurück gegeben.
Hinweise
Ein Codebeispiel finden Sie unter map::erase.
unordered_multimap::find
Sucht ein Element, das einem angegebenen Schlüssel entspricht.
const_iterator find(const Key& keyval) const;
Parameter
keyval
Der zu suchende Schlüsselwert.
Hinweise
Die Memberfunktion gibt unordered_multimap::equal_range(keyval).first zurück.
Beispiel
// std__unordered_map__unordered_multimap_find.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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
Mymap::iterator it = c1.find('b');
std::cout << "find('b') == "
<< std::boolalpha << (it != c1.end())
<< ": [" << it->first << ", " << it->second << "]" << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
find('A') == false
find('b') == true: [b, 2]
unordered_multimap::get_allocator
Ruft das gespeicherte Zuweisungsobjekt ab.
Alloc get_allocator() const;
Hinweise
Die Memberfunktion gibt das gespeicherte Zuweisungsobjekt zurück.
Beispiel
// std__unordered_map__unordered_multimap_get_allocator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
Mymap c1;
Mymap::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
unordered_multimap::hash_function
Ruft das gespeicherte Hashfunktionsobjekt ab.
Hash hash_function() const;
Hinweise
Die Memberfunktion gibt das gespeicherte Hashfunktionsobjekt zurück.
Beispiel
// std__unordered_map__unordered_multimap_hash_function.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::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
unordered_multimap::hasher
Der Typ der Hashfunktion.
typedef Hash hasher;
Hinweise
Der Type stellt ein Synonym für den Vorlagenparameter Hashdar.
Beispiel
// std__unordered_map__unordered_multimap_hasher.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::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
unordered_multimap::insert
Fügt ein Element oder einen Bereich von Elementen in ein unordered_multimap-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);
Parameter
Val
Der Wert eines in das unordered_multimap-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 die unordered_multimap 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.
Rückgabewert
Die Einzelelement-Memberfunktionen (1) und (2) geben einen Iterator an die Position zurück, an der das neue Element in das unordered_multimap-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_multimap-Element eingefügt wurde.
Hinweise
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 Typedef, die dem Container angehört. Bei einer Zuordnung ist map<K, V>::value_typepair<const K, V>. Der Wert eines Elements ist ein sortiertes Paar, in dem die erste Komponente gleich dem Schlüsselwert und die zweite Komponente gleich dem Datenwert des Elements ist.
Die Bereichsmemmfunktion (5) fügt die Abfolge von Elementwerten in eine unordered_multimap 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_multimap 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_multimap::emplace und unordered_multimap::emplace_hint.
Ein Codebeispiel finden Sie unter multimap::insert.
unordered_multimap::iterator
Der Typ eines Iterators für die gesteuerte Sequenz.
typedef T0 iterator;
Hinweise
Der Typ beschreibt ein Objekt, das als Forward-Iterator für die gesteuerte Sequenz fungieren kann. Er wird hier als Synonym für einen durch Implementierung definierten T0-Typ beschrieben.
Beispiel
// std__unordered_map__unordered_multimap_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::key_eq
Ruft das gespeicherte Vergleichsfunktionsobjekt ab.
Pred key_eq() const;
Hinweise
Die Memberfunktion gibt das gespeicherte Vergleichsfunktionsobjekt zurück.
Beispiel
// std__unordered_map__unordered_multimap_key_eq.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::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
unordered_multimap::key_equal
Der Typ der Vergleichsfunktion.
typedef Pred key_equal;
Hinweise
Der Type stellt ein Synonym für den Vorlagenparameter Preddar.
Beispiel
// std__unordered_map__unordered_multimap_key_equal.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::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
unordered_multimap::key_type
Der Typ eines Sortierschlüssels.
typedef Key key_type;
Hinweise
Der Type stellt ein Synonym für den Vorlagenparameter Keydar.
Beispiel
// std__unordered_map__unordered_multimap_key_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// add a value and reinspect
Mymap::key_type key = 'd';
Mymap::mapped_type mapped = 4;
Mymap::value_type val = Mymap::value_type(key, mapped);
c1.insert(val);
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]
unordered_multimap::load_factor
Zählt die durchschnittliche Anzahl von Elementen pro Bucket.
float load_factor() const;
Hinweise
Die Memberfunktion gibt (float)unordered_multimap::size() / (float)unordered_multimap::bucket_count() zurück, also die durchschnittliche Anzahl von Elementen pro Bucket.
Beispiel
// std__unordered_map__unordered_multimap_load_factor.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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);
}
unordered_multimap::local_iterator
Der Typ eines Bucketiterators.
typedef T4 local_iterator;
Hinweise
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.
Beispiel
// std__unordered_map__unordered_multimap_local_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect bucket containing 'a'
Mymap::local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << " [" << lit->first << ", " << lit->second << "]";
return (0);
}
[c, 3] [b, 2] [a, 1]
[a, 1]
unordered_multimap::mapped_type
Der Typ eines zugeordneten Werts, der jedem Schlüssel zugeordnet ist.
typedef Ty mapped_type;
Hinweise
Der Type stellt ein Synonym für den Vorlagenparameter Tydar.
Beispiel
// std__unordered_map__unordered_multimap_mapped_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// add a value and reinspect
Mymap::key_type key = 'd';
Mymap::mapped_type mapped = 4;
Mymap::value_type val = Mymap::value_type(key, mapped);
c1.insert(val);
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]
unordered_multimap::max_bucket_count
Ruft die maximale Anzahl von Buckets ab.
size_type max_bucket_count() const;
Hinweise
Die Memberfunktion gibt die maximale Anzahl von Buckets zurück, die derzeit zulässig ist.
Beispiel
// std__unordered_map__unordered_multimap_max_bucket_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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, 3] [b, 2] [a, 1]
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
unordered_multimap::max_load_factor
Ruft die maximale Anzahl von Elementen pro Bucket ab oder legt sie fest.
float max_load_factor() const;
void max_load_factor(float factor);
Parameter
Faktor
Der neue maximale Lastfaktor.
Hinweise
Die erste Memberfunktion gibt den gespeicherten maximalen Lastfaktor zurück. Die zweite Memberfunktion ersetzt den gespeicherten maximalen Ladefaktor durch Faktor.
Beispiel
// std__unordered_map__unordered_multimap_max_load_factor.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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, 3] [b, 2] [a, 1]
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
unordered_multimap::max_size
Ruft die maximale Größe der gesteuerten Sequenz ab.
size_type max_size() const;
Hinweise
Die Memberfunktion gibt die Länge der längsten Sequenz zurück, die das Objekt steuern kann.
Beispiel
// std__unordered_map__unordered_multimap_max_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
std::cout << "max_size() == " << c1.max_size() << std::endl;
return (0);
}
max_size() == 536870911
unordered_multimap::operator=
Kopiert eine Hashtabelle.
unordered_multimap& operator=(const unordered_multimap& right);
unordered_multimap& operator=(unordered_multimap&& right);
Parameter
right
Das unordered_multimap kopierte In das unordered_multimap.
Hinweise
Nach dem Löschen vorhandener Elemente in einem unordered_multimap kopiert operator= oder der Inhalt von rechts in die unordered_multimap verschoben.
Beispiel
// unordered_multimap_operator_as.cpp
// compile with: /EHsc
#include <unordered_multimap>
#include <iostream>
int main( )
{
using namespace std;
unordered_multimap<int, int> v1, v2, v3;
unordered_multimap<int, int>::iterator iter;
v1.insert(pair<int, int>(1, 10));
cout << "v1 = " ;
for (iter = v1.begin(); iter != v1.end(); iter++)
cout << iter->second << " ";
cout << endl;
v2 = v1;
cout << "v2 = ";
for (iter = v2.begin(); iter != v2.end(); iter++)
cout << iter->second << " ";
cout << endl;
// move v1 into v2
v2.clear();
v2 = move(v1);
cout << "v2 = ";
for (iter = v2.begin(); iter != v2.end(); iter++)
cout << iter->second << " ";
cout << endl;
}
unordered_multimap::pointer
Der Typ eines Zeigers auf ein Element.
typedef Alloc::pointer pointer;
Hinweise
Der Typ beschreibt ein Objekt, das als Zeiger auf ein Element der gesteuerten Sequenz fungieren kann.
Beispiel
// std__unordered_map__unordered_multimap_pointer.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
{
Mymap::pointer p = &*it;
std::cout << " [" << p->first << ", " << p->second << "]";
}
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::reference
Der Typ eines Verweises auf ein Element.
typedef Alloc::reference reference;
Hinweise
Der Typ beschreibt ein Objekt, das als Verweis auf ein Element der gesteuerten Sequenz fungieren kann.
Beispiel
// std__unordered_map__unordered_multimap_reference.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
{
Mymap::reference ref = *it;
std::cout << " [" << ref.first << ", " << ref.second << "]";
}
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::rehash
Erstellt die Hashtabelle neu.
void rehash(size_type nbuckets);
Parameter
nbuckets
Die angeforderte Anzahl von Buckets.
Hinweise
Die Memberfunktion ändert die Anzahl der Buckets, die mindestens nbuckets sind, und erstellt die Hashtabelle nach Bedarf neu.
Beispiel
// std__unordered_map__unordered_multimap_rehash.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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, 3] [b, 2] [a, 1]
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
unordered_multimap::size
Ermittelt die Anzahl von Elementen.
size_type size() const;
Hinweise
Die Memberfunktion gibt die Länge der gesteuerten Sequenz zurück.
Beispiel
// std__unordered_map__unordered_multimap_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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(Mymap::value_type('d', 4));
c1.insert(Mymap::value_type('e', 5));
// display contents " [e 5] [d 4]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
size == 0
empty() == true
[e, 5] [d, 4]
size == 2
empty() == false
unordered_multimap::size_type
Der Typ eines Abstands ohne Vorzeichen zwischen zwei Elementen.
typedef T2 size_type;
Hinweise
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.
Beispiel
// std__unordered_map__unordered_multimap_size_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::size_type sz = c1.size();
std::cout << "size == " << sz << std::endl;
return (0);
}
size == 0
unordered_multimap::swap
Vertauscht den Inhalt von zwei Containern.
void swap(unordered_multimap& right);
Parameter
right
Der Container für den Tauschvorgang.
Hinweise
Die Memberfunktion wechselt die gesteuerten Sequenzen zwischen *this und rechts. Wenn unordered_multimap::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.
Beispiel
// std__unordered_map__unordered_multimap_swap.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
Mymap c2;
c2.insert(Mymap::value_type('d', 4));
c2.insert(Mymap::value_type('e', 5));
c2.insert(Mymap::value_type('f', 6));
c1.swap(c2);
// display contents " [f 6] [e 5] [d 4]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
swap(c1, c2);
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
[f, 6] [e, 5] [d, 4]
[c, 3] [b, 2] [a, 1]
unordered_multimap::unordered_multimap
Erstellt ein container-Objekt.
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());
Parameter
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 die Elemente kopiert werden sollen.
Hinweise
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 Gibt eine Kopie der Sequenz an, indem Sie nach rechts verschieben. Bei den vierten, fünften sechsten, siebten und achten Konstruktoren wird ein initializer_list-Element für die Member verwendet. Mit dem neunten Konstruktor wird die Elementwertesequenz [First, Last) eingefügt.
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 Pred()es .
The allocator object is the argument Al, if present; otherwise, it is Alloc().
Beispiel
// 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, hash<char>> c7(
{ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
4,
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, hash<char>, equal_to<char>> c8(
{ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
4,
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, hash<char>, equal_to<char>> c9(
{ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
4,
hash<char>(),
equal_to<char>(),
allocator<pair<const char, int> >()
);
for (const auto& c : c1) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
}
[a, 1] [b, 2] [c, 3] [d, 4] [e, 5] [f, 6] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [5, g] [6, h] [7, i] [8, j] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [c, 3] [b, 2] [a, 1]
[f, 6] [e, 5] [d, 4]
[c, 3] [b, 2] [a, 1]
[c, 3] [b, 2] [a, 1]
unordered_multimap::value_type
Der Typ eines Elements.
typedef std::pair<const Key, Ty> value_type;
Hinweise
Der Typ beschreibt ein Element der gesteuerten Sequenz.
Beispiel
// std__unordered_map__unordered_multimap_value_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
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 (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// add a value and reinspect
Mymap::key_type key = 'd';
Mymap::mapped_type mapped = 4;
Mymap::value_type val = Mymap::value_type(key, mapped);
c1.insert(val);
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]
Siehe auch
<unordered_map>
Container
Threadsicherheit in der C++-Standardbibliothek
C++-Standardbibliotheksreferenz