hash_map (STL/CLR)
Die Vorlagenklasse beschreibt ein Objekt, das eine unterschiedliche Sequenz von Elementen mit bidirektionalem Zugriff steuert. Sie verwenden den Container hash_map , um eine Abfolge von Elementen als Hashtabelle zu verwalten, jeder Tabelleneintrag, der eine bidirektionale verknüpfte Liste von Knoten speichert, und jeden Knoten, der ein Element speichert. Ein Element besteht aus einem Schlüssel, zum Sortieren der Sequenz und einem zugeordneten Wert, der für die Fahrt entlanggeht.
In der nachstehenden GValue Beschreibung ist die gleiche wie:
Microsoft::VisualC::StlClr::GenericPair<GKey, GMapped>
Dabei gilt Folgendes:
GKey ist identisch mit Key dem, es sei denn, dies ist ein Bezugstyp, in diesem Fall ist es Key^
GMapped ist identisch mit Mapped dem, es sei denn, dies ist ein Bezugstyp, in diesem Fall ist es Mapped^
Syntax
template<typename Key,
typename Mapped>
ref class hash_map
: public
System::ICloneable,
System::Collections::IEnumerable,
System::Collections::ICollection,
System::Collections::Generic::IEnumerable<GValue>,
System::Collections::Generic::ICollection<GValue>,
System::Collections::Generic::IList<GValue>,
System::Collections::Generic::IDictionary<Gkey, GMapped>,
Microsoft::VisualC::StlClr::IHash<Gkey, GValue>
{ ..... };
Parameter
Key
Der Typ der Schlüsselkomponente eines Elements in der gesteuerten Sequenz.
Mapped
Der Typ der anderen Komponente eines Elements in der gesteuerten Sequenz.
Anforderungen
Header:<cliext/hash_map>
Namespace:cliext
Deklarationen
| Typdefinition | Beschreibung |
|---|---|
hash_map::const_iterator |
Der Typ eines konstanten Iterators für die gesteuerte Sequenz. |
hash_map::const_reference |
Der Typ eines konstanten Verweises auf ein Element. |
hash_map::const_reverse_iterator |
Der Typ eines konstanten umgekehrten Iterators für die gesteuerte Sequenz. |
hash_map::difference_type |
Der Typ eines (möglicherweise signierten) Abstands zwischen zwei Elementen. |
hash_map::generic_container |
Der Typ der generischen Schnittstelle für den Container. |
hash_map::generic_iterator |
Der Typ eines Iterators für die generische Schnittstelle für den Container. |
hash_map::generic_reverse_iterator |
Der Typ eines Reverse iterators für die generische Schnittstelle für den Container. |
hash_map::generic_value |
Der Typ eines Elements für die generische Schnittstelle für den Container. |
hash_map::hasher |
Der Hashingdelegat für einen Schlüssel. |
hash_map::iterator |
Der Typ eines Iterators für die gesteuerte Sequenz. |
hash_map::key_compare |
Der Sortierdelegat für zwei Schlüssel. |
hash_map::key_type |
Der Typ eines Sortierschlüssels. |
hash_map::mapped_type |
Der Typ des zugeordneten Werts, der den einzelnen Schlüsseln zugeordnet ist. |
hash_map::reference |
Der Typ eines Verweises auf ein Element. |
hash_map::reverse_iterator |
Der Typ eines umgekehrten Iterators für die gesteuerte Sequenz. |
hash_map::size_type |
Der Typ eines (nicht negativen) Abstands zwischen zwei Elementen. |
hash_map::value_compare |
Der Sortierdelegat für zwei Elementwerte. |
hash_map::value_type |
Der Typ eines Elements. |
| Memberfunktion | Beschreibung |
|---|---|
hash_map::begin |
Legt den Anfang der kontrollierten Sequenz fest. |
hash_map::bucket_count |
Zählt die Anzahl der Buckets. |
hash_map::clear |
Entfernt alle Elemente. |
hash_map::count |
Zählt Elemente, die einem angegebenen Schlüssel entsprechen. |
hash_map::empty |
Testet, ob keine Elemente vorhanden sind. |
hash_map::end |
Legt das Ende der kontrollierten Sequenz fest. |
hash_map::equal_range |
Sucht den Bereich, der einem angegebenen Schlüssel entspricht. |
hash_map::erase |
Entfernt Elemente an den angegebenen Positionen. |
hash_map::find |
Sucht ein Element, das einem angegebenen Schlüssel entspricht. |
hash_map::hash_delegate |
Kopiert den Hashingdelegat für einen Schlüssel. |
hash_map::hash_map |
Erstellt ein container-Objekt. |
hash_map::insert |
Fügt Elemente hinzu. |
hash_map::key_comp |
Kopiert den Sortierdelegat für zwei Schlüssel. |
hash_map::load_factor |
Zählt die durchschnittliche Anzahl von Elementen pro Bucket. |
hash_map::lower_bound |
Sucht den Anfang des Bereichs, der einem angegebenen Schlüssel entspricht. |
hash_map::make_value |
Erstellt ein Wertobjekt. |
hash_map::max_load_factor |
Ruft die maximale Anzahl von Elementen pro Bucket ab oder legt sie fest. |
hash_map::rbegin |
Legt den Anfang der umgekehrten kontrollierten Sequenz fest. |
hash_map::rehash |
Erstellt die Hashtabelle neu. |
hash_map::rend |
Legt das Ende der umgekehrten kontrollierten Sequenz fest. |
hash_map::size |
Ermittelt die Anzahl von Elementen. |
hash_map::swap |
Vertauscht den Inhalt von zwei Containern. |
hash_map::to_array |
Kopiert die kontrollierte Sequenz in ein neues Array. |
hash_map::upper_bound |
Sucht das Ende des Bereichs, der einem angegebenen Schlüssel entspricht. |
hash_map::value_comp |
Kopiert den Sortierdelegat für zwei Elementwerte. |
| Operator | Beschreibung |
|---|---|
hash_map::operator= |
Ersetzt die kontrollierte Sequenz. |
hash_map::operator[] |
Ordnet einen Schlüssel dem zugeordneten zugeordneten Wert zu. |
Schnittstellen
| Schnittstelle | Beschreibung |
|---|---|
| ICloneable | Duplizieren Eines Objekts. |
| IEnumerable | Sequenzieren durch Elemente. |
| ICollection | Verwalten sie eine Gruppe von Elementen. |
| IEnumerable<T> | Sequenz durch eingegebene Elemente. |
| ICollection<T> | Verwalten der Gruppe von typierten Elementen. |
| IDictionary<TKey,TValue> | Verwalten der Gruppe von {key,value}-Paaren. |
IHash<Key, Value> |
Verwalten Sie generischen Container. |
Hinweise
Das Objekt reserviert und gibt Speicherplatz für die Sequenz frei, die es als einzelne Knoten in einer bidirektionalen verknüpften Liste steuert. Um den Zugriff zu beschleunigen, verwaltet das Objekt auch ein Array mit unterschiedlichen Zeigern in der Liste (die Hashtabelle), verwaltet die gesamte Liste effektiv als Abfolge von Unterlisten oder Buckets. Es fügt Elemente in einen Bucket ein, der sortiert bleibt, indem die Verknüpfungen zwischen Knoten geändert werden, niemals durch Kopieren des Inhalts eines Knotens in einen anderen. Das bedeutet, dass Sie Elemente frei einfügen und entfernen können, ohne die verbleibenden Elemente zu stören.
Das Objekt sortiert jeden Bucket, den er steuert, indem ein gespeichertes Delegatobjekt vom Typ hash_set::key_compareaufgerufen wird. Sie können das gespeicherte Delegatobjekt angeben, wenn Sie das hash_set erstellen. wenn Sie kein Delegatobjekt angeben, ist der Standardwert der Vergleich operator<=(key_type, key_type).
Sie greifen auf das gespeicherte Delegatenobjekt zu, indem Sie die Memberfunktion hash_set::key_comp()aufrufen. Ein solches Delegatobjekt muss eine gleichwertige Sortierung zwischen Schlüsseln vom Typ hash_set::key_typedefinieren. Dies bedeutet, dass für alle zwei Schlüssel X und Y:
key_comp()(X, Y) gibt dasselbe boolesche Ergebnis für jeden Anruf zurück.
Wenn key_comp()(X, Y) && key_comp()(Y, X) dies der Fall ist, dann und Y wird davon gesprochen, X dass sie eine gleichwertige Sortierung haben.
Jede Sortierregel, die sich wie operator<=(key_type, key_type)folgt verhält, operator>=(key_type, key_type) oder operator==(key_type, key_type) definiert die entsprechende Sortierung.
Der Container stellt nur sicher, dass Elemente, deren Schlüssel eine gleichwertige Reihenfolge aufweisen (und welcher Hash auf denselben ganzzahligen Wert) innerhalb eines Buckets angrenzen. Im Gegensatz zur Vorlagenklasse hash_multimapstellt ein Objekt der Vorlagenklasse hash_map sicher, dass Schlüssel für alle Elemente eindeutig sind. (Keine zwei Schlüssel weisen eine gleichwertige Reihenfolge auf.)
Das Objekt bestimmt, welcher Bucket einen bestimmten Sortierschlüssel enthalten soll, indem ein gespeichertes Delegatenobjekt vom Typ hash_set::hasheraufgerufen wird. Sie greifen auf dieses gespeicherte Objekt zu, indem Sie die Memberfunktion hash_set::hash_delegate aufrufen, um einen ganzzahligen Wert abzurufen, der vom Schlüsselwert abhängt. Sie können das gespeicherte Delegatobjekt angeben, wenn Sie das hash_set erstellen. wenn Sie kein Delegatobjekt angeben, ist die Standardfunktion System::Object::hash_value(key_type). Das bedeutet für alle Schlüssel X und Y:
hash_delegate()(X) gibt dasselbe ganzzahlige Ergebnis für jeden Aufruf zurück.
Wenn X und Y eine entsprechende Sortierung vorhanden ist, hash_delegate()(X) sollte dasselbe ganzzahlige Ergebnis zurückgegeben werden wie hash_delegate()(Y).
Jedes Element enthält einen separaten Schlüssel und einen zugeordneten Wert. Die Sequenz wird in einer Weise dargestellt, die das Nachschlagen, Einfügen und Entfernen eines beliebigen Elements in konstanter Zeit zulässt. Das heißt, die Anzahl der Vorgänge ist unabhängig von der Anzahl der Elemente in der Sequenz, zumindest in den besten Fällen. Darüber hinaus wird durch das Einfügen eines Elements keine Iteratoren ungültig, und durch das Entfernen eines Elements werden nur die Iteratoren ungültig, die auf das entfernte Element zeigen.
Wenn Hashwerte jedoch nicht einheitlich verteilt werden, kann eine Hashtabelle degenerieren. Im Extrem (für eine Hashfunktion, die immer denselben Wert zurückgibt), sind Nachschlage-, Einfügungs- und Entfernungsvorgänge proportional zur Anzahl der Elemente in der Sequenz (lineare Zeit). Der Container bemüht sich, eine angemessene Hashfunktion, mittlere Bucketgröße und Hashtabellengröße (Gesamtanzahl der Buckets) auszuwählen, Sie können jedoch beliebige oder alle diese Optionen außer Kraft setzen. Siehe z. B. die Funktionen hash_set::max_load_factor und hash_set::rehash.
A hash_map supports bidirectional iterators, which means you can step to adjacent elements given an iterator that designates an element in the controlled sequence. Ein spezieller Kopfknoten entspricht dem iterator, von end()dem zurückgegeben wird. Sie können diesen Iterator verringern, um das letzte Element in der gesteuerten Sequenz zu erreichen, falls vorhanden. Sie können einen hash_map Iterator erhöhen, um den Kopfknoten zu erreichen, und es wird dann gleich end()verglichen. Sie können jedoch nicht ableiten, von dem der Iterator zurückgegeben wird end().
Sie können nicht direkt auf ein hash_map Element verweisen, das seine numerische Position angibt. Dies erfordert einen Iterator mit wahlfreiem Zugriff.
Ein hash_map Iterator speichert ein Handle für den zugeordneten hash_map Knoten, der wiederum ein Handle für den zugeordneten Container speichert. Sie können Iteratoren nur mit den zugehörigen Containerobjekten verwenden. Ein hash_map Iterator bleibt gültig, solange der zugeordnete hash_map Knoten einigen hash_mapzugeordnet ist. Darüber hinaus ist ein gültiger Iterator ableitend. Sie können ihn verwenden, um auf den von ihr angegebenen Elementwert zuzugreifen oder ihn zu ändern, solange er nicht gleich ist end().
Beim Löschen oder Entfernen eines Elements wird der Destruktor für den gespeicherten Wert aufgerufen. Durch das Zerstören des Containers werden alle Elemente gelöscht. Daher stellt ein Container, dessen Elementtyp eine Ref-Klasse ist, sicher, dass keine Elemente den Container überleben. Beachten Sie jedoch, dass ein Container von Handles seine Elemente nicht* zerstört.
Member
hash_map::begin
Legt den Anfang der kontrollierten Sequenz fest.
Syntax
iterator begin();
Hinweise
Die Memberfunktion gibt einen bidirektionalen Iterator zurück, der das erste Element der gesteuerten Sequenz oder direkt über das Ende einer leeren Sequenz bestimmt. Sie verwenden es, um einen Iterator zu erhalten, der den current Anfang der kontrollierten Sequenz angibt, aber sein Status kann sich ändern, wenn sich die Länge der kontrollierten Sequenz ändert.
Beispiel
// cliext_hash_map_begin.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// inspect first two items
Myhash_map::iterator it = c1.begin();
System::Console::WriteLine("*begin() = [{0} {1}]",
it->first, it->second);
++it;
System::Console::WriteLine("*++begin() = [{0} {1}]",
it->first, it->second);
return (0);
}
[a 1] [b 2] [c 3]
*begin() = [a 1]
*++begin() = [b 2]
hash_map::bucket_count
Zählt die Anzahl der Buckets.
Syntax
int bucket_count();
Hinweise
Die Memberfunktion gibt die aktuelle Anzahl von Buckets zurück. Sie verwenden es, um die Größe der Hashtabelle zu bestimmen.
Beispiel
// cliext_hash_map_bucket_count.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1 = gcnew Myhash_map;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// inspect current parameters
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// change max_load_factor and redisplay
c1.max_load_factor(0.25f);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// rehash and redisplay
c1.rehash(100);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
return (0);
}
[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25
bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25
hash_map::clear
Entfernt alle Elemente.
Syntax
void clear();
Hinweise
Die Memberfunktion ruft effektiv auf erase(begin(), end()). Sie verwenden es, um sicherzustellen, dass die kontrollierte Sequenz leer ist.
Beispiel
// cliext_hash_map_clear.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
// display contents " [a 1] [b 2]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
return (0);
}
[a 1] [b 2] [c 3]
size() = 0
[a 1] [b 2]
size() = 0
hash_map::const_iterator
Der Typ eines konstanten Iterators für die gesteuerte Sequenz.
Syntax
typedef T2 const_iterator;
Hinweise
Der Typ beschreibt ein Objekt nicht angegebener Typs T2 , das als konstanter bidirektionaler Iterator für die kontrollierte Sequenz dienen kann.
Beispiel
// cliext_hash_map_const_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
Myhash_map::const_iterator cit = c1.begin();
for (; cit != c1.end(); ++cit)
System::Console::Write("[{0} {1}] ", cit->first, cit->second);
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]
hash_map::const_reference
Der Typ eines konstanten Verweises auf ein Element.
Syntax
typedef value_type% const_reference;
Hinweise
Der Typ beschreibt einen Konstantenverweis auf ein Element.
Beispiel
// cliext_hash_map_const_reference.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
Myhash_map::const_iterator cit = c1.begin();
for (; cit != c1.end(); ++cit)
{ // get a const reference to an element
Myhash_map::const_reference cref = *cit;
System::Console::Write("[{0} {1}] ", cref->first, cref->second);
}
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]
hash_map::const_reverse_iterator
Der Typ eines konstanten umgekehrten Iterators für die gesteuerte Sequenz.
Syntax
typedef T4 const_reverse_iterator;
Hinweise
Der Typ beschreibt ein Objekt nicht angegebener Typs T4 , das als konstanten Reverse iterator für die kontrollierte Sequenz dienen kann.
Beispiel
// cliext_hash_map_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]" reversed
Myhash_map::const_reverse_iterator crit = c1.rbegin();
for (; crit != c1.rend(); ++crit)
System::Console::Write("[{0} {1}] ", crit->first, crit->second);
System::Console::WriteLine();
return (0);
}
[c 3] [b 2] [a 1]
hash_map::count
Sucht die Anzahl von Elementen, die einem angegebenen Schlüssel entsprechen.
Syntax
size_type count(key_type key);
Parameter
key
Der zu suchende Schlüsselwert.
Hinweise
Die Memberfunktion gibt die Anzahl der Elemente in der kontrollierten Sequenz zurück, die eine entsprechende Reihenfolge aufweisen.key Sie verwenden es, um die Anzahl der Elemente zu bestimmen, die sich derzeit in der kontrollierten Sequenz befindet, die einem angegebenen Schlüssel entsprechen.
Beispiel
// cliext_hash_map_count.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
System::Console::WriteLine("count(L'A') = {0}", c1.count(L'A'));
System::Console::WriteLine("count(L'b') = {0}", c1.count(L'b'));
System::Console::WriteLine("count(L'C') = {0}", c1.count(L'C'));
return (0);
}
[a 1] [b 2] [c 3]
count(L'A') = 0
count(L'b') = 1
count(L'C') = 0
hash_map::difference_type
Die Typen eines signierten Abstands zwischen zwei Elementen.
Syntax
typedef int difference_type;
Hinweise
Der Typ beschreibt eine möglicherweise negative Elementanzahl.
Beispiel
// cliext_hash_map_difference_type.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// compute positive difference
Myhash_map::difference_type diff = 0;
for (Myhash_map::iterator it = c1.begin(); it != c1.end(); ++it)
++diff;
System::Console::WriteLine("end()-begin() = {0}", diff);
// compute negative difference
diff = 0;
for (Myhash_map::iterator it = c1.end(); it != c1.begin(); --it)
--diff;
System::Console::WriteLine("begin()-end() = {0}", diff);
return (0);
}
[a 1] [b 2] [c 3]
end()-begin() = 3
begin()-end() = -3
hash_map::empty
Testet, ob keine Elemente vorhanden sind.
Syntax
bool empty();
Hinweise
Die Memberfunktion gibt für eine leere kontrollierte Sequenz zurück true . Dies entspricht size() == 0. Sie verwenden es, um zu testen, ob die Datei hash_map leer ist.
Beispiel
// cliext_hash_map_empty.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
System::Console::WriteLine("size() = {0}", c1.size());
System::Console::WriteLine("empty() = {0}", c1.empty());
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
System::Console::WriteLine("empty() = {0}", c1.empty());
return (0);
}
[a 1] [b 2] [c 3]
size() = 3
empty() = False
size() = 0
empty() = True
hash_map::end
Legt das Ende der kontrollierten Sequenz fest.
Syntax
iterator end();
Hinweise
Die Memberfunktion gibt einen bidirektionalen Iterator zurück, der unmittelbar über das Ende der gesteuerten Sequenz verweist. Sie verwenden es, um einen Iterator zu erhalten, der das Ende der kontrollierten Sequenz angibt; der Status ändert sich nicht, wenn sich die Länge der kontrollierten Sequenz ändert.
Beispiel
// cliext_hash_map_end.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// inspect last two items
Myhash_map::iterator it = c1.end();
--it;
--it;
System::Console::WriteLine("*-- --end() = [{0} {1}]",
it->first, it->second);
++it;
System::Console::WriteLine("*--end() = [{0} {1}]",
it->first, it->second);
return (0);
}
[a 1] [b 2] [c 3]
*-- --end() = [b 2]
*--end() = [c 3]
hash_map::equal_range
Sucht den Bereich, der einem angegebenen Schlüssel entspricht.
Syntax
cliext::pair<iterator, iterator> equal_range(key_type key);
Parameter
key
Der zu suchende Schlüsselwert.
Hinweise
Die Memberfunktion gibt ein Iteratorpaar cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key))zurück. Sie verwenden es, um den Bereich der Elemente zu bestimmen, die sich derzeit in der kontrollierten Sequenz befinden, die einem angegebenen Schlüssel entsprechen.
Beispiel
// cliext_hash_map_equal_range.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
typedef Myhash_map::pair_iter_iter Pairii;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// display results of failed search
Pairii pair1 = c1.equal_range(L'x');
System::Console::WriteLine("equal_range(L'x') empty = {0}",
pair1.first == pair1.second);
// display results of successful search
pair1 = c1.equal_range(L'b');
for (; pair1.first != pair1.second; ++pair1.first)
System::Console::Write("[{0} {1}] ",
pair1.first->first, pair1.first->second);
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]
equal_range(L'x') empty = True
[b 2]
hash_map::erase
Entfernt Elemente an den angegebenen Positionen.
Syntax
iterator erase(iterator where);
iterator erase(iterator first, iterator last);
bool erase(key_type key)
Parameter
first
Anfang des zu löschenden Bereichs.
key
Schlüsselwert, der gelöscht werden soll.
last
Ende des zu löschenden Bereichs.
where
Element, das gelöscht werden soll.
Hinweise
Die erste Memberfunktion entfernt das Element der kontrollierten Abfolge, auf die verwiesen wherewird, und gibt einen Iterator zurück, der das erste Element angibt, das über das entfernte Element hinaus verbleibt, oder end() wenn kein solches Element vorhanden ist. Sie verwenden es, um ein einzelnes Element zu entfernen.
Die zweite Memberfunktion entfernt die Elemente der kontrollierten Sequenz im Bereich [first, ), und gibt einen Iterator zurück, lastder das erste Element angibt, das über alle entfernten Elemente hinaus verbleibt, oder end() wenn kein solches Element vorhanden ist. Sie verwenden es, um null oder mehr zusammenhängende Elemente zu entfernen.
Die dritte Memberfunktion entfernt alle Elemente der gesteuerten Sequenz, deren Schlüssel die entsprechende Reihenfolge keyaufweist, und gibt eine Anzahl der entfernten Elemente zurück. Sie verwenden es, um alle Elemente zu entfernen und zu zählen, die einem angegebenen Schlüssel entsprechen.
Jedes Elementlöschung dauert Zeit proportional zum Logarithmus der Anzahl der Elemente in der kontrollierten Sequenz.
Beispiel
// cliext_hash_map_erase.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
cliext::hash_map<wchar_t, int> c1;
c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'a', 1));
c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'b', 2));
c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (cliext::hash_map<wchar_t, int>::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// erase an element and reinspect
cliext::hash_map<wchar_t, int>::iterator it =
c1.erase(c1.begin());
System::Console::WriteLine("erase(begin()) = [{0} {1}]",
it->first, it->second);
// add elements and display " b c d e"
c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'd', 4));
c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'e', 5));
for each (cliext::hash_map<wchar_t, int>::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// erase all but end
it = c1.end();
it = c1.erase(c1.begin(), --it);
System::Console::WriteLine("erase(begin(), end()-1) = [{0} {1}]",
it->first, it->second);
System::Console::WriteLine("size() = {0}", c1.size());
// erase end
System::Console::WriteLine("erase(L'x') = {0}", c1.erase(L'x'));
System::Console::WriteLine("erase(L'e') = {0}", c1.erase(L'e'));
return (0);
}
[a 1] [b 2] [c 3]
erase(begin()) = [b 2]
[b 2] [c 3] [d 4] [e 5]
erase(begin(), end()-1) = [e 5]
size() = 1
erase(L'x') = 0
erase(L'e') = 1
hash_map::find
Sucht ein Element, das einem angegebenen Schlüssel entspricht.
Syntax
iterator find(key_type key);
Parameter
key
Der zu suchende Schlüsselwert.
Hinweise
Wenn mindestens ein Element in der kontrollierten Sequenz eine gleichwertige Reihenfolge aufweist key, gibt die Memberfunktion einen Iterator zurück, der eines dieser Elemente bestimmt; andernfalls wird es zurückgegeben end(). Sie verwenden es, um ein Element zu finden, das sich derzeit in der kontrollierten Sequenz befindet, die einem angegebenen Schlüssel entspricht.
Beispiel
// cliext_hash_map_find.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
System::Console::WriteLine("find {0} = {1}",
L'A', c1.find(L'A') != c1.end());
Myhash_map::iterator it = c1.find(L'b');
System::Console::WriteLine("find {0} = [{1} {2}]",
L'b', it->first, it->second);
System::Console::WriteLine("find {0} = {1}",
L'C', c1.find(L'C') != c1.end());
return (0);
}
[a 1] [b 2] [c 3]
find A = False
find b = [b 2]
find C = False
hash_map::generic_container
Der Typ der generischen Schnittstelle für den Container.
Syntax
typedef Microsoft::VisualC::StlClr::
IHash<GKey, GValue>
generic_container;
Hinweise
Der Typ beschreibt die generische Schnittstelle für diese Vorlagencontainerklasse.
Beispiel
// cliext_hash_map_generic_container.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// construct a generic container
Myhash_map::generic_container^ gc1 = %c1;
for each (Myhash_map::value_type elem in gc1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// modify generic and display original
gc1->insert(Myhash_map::make_value(L'd', 4));
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// modify original and display generic
c1.insert(Myhash_map::make_value(L'e', 5));
for each (Myhash_map::value_type elem in gc1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3] [d 4]
[a 1] [b 2] [c 3] [d 4] [e 5]
hash_map::generic_iterator
Der Typ eines Iterators für die Verwendung mit der generischen Schnittstelle für den Container.
Syntax
typedef Microsoft::VisualC::StlClr::Generic::
ContainerBidirectionalIterator<generic_value>
generic_iterator;
Hinweise
Der Typ beschreibt einen generischen Iterator, der mit der generischen Schnittstelle für diese Vorlagencontainerklasse verwendet werden kann.
Beispiel
// cliext_hash_map_generic_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// construct a generic container
Myhash_map::generic_container^ gc1 = %c1;
for each (Myhash_map::value_type elem in gc1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// get an element and display it
Myhash_map::generic_iterator gcit = gc1->begin();
Myhash_map::generic_value gcval = *gcit;
System::Console::Write("[{0} {1}] ", gcval->first, gcval->second);
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1]
hash_map::generic_reverse_iterator
Der Typ eines Reverse iterators für die Verwendung mit der generischen Schnittstelle für den Container.
Syntax
typedef Microsoft::VisualC::StlClr::Generic::
ReverseRandomAccessIterator<generic_value>
generic_reverse_iterator;
Hinweise
Der Typ beschreibt einen generischen Reverse iterator, der mit der generischen Schnittstelle für diese Vorlagencontainerklasse verwendet werden kann.
Beispiel
// cliext_hash_map_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// construct a generic container
Myhash_map::generic_container^ gc1 = %c1;
for each (Myhash_map::value_type elem in gc1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// get an element and display it
Myhash_map::generic_reverse_iterator gcit = gc1->rbegin();
Myhash_map::generic_value gcval = *gcit;
System::Console::WriteLine("[{0} {1}] ", gcval->first, gcval->second);
return (0);
}
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[c 3]
hash_map::generic_value
Der Typ eines Elements für die Verwendung mit der generischen Schnittstelle für den Container.
Syntax
typedef GValue generic_value;
Hinweise
Der Typ beschreibt ein Objekt vom Typ GValue , das den gespeicherten Elementwert für die Verwendung mit der generischen Schnittstelle für diese Vorlagencontainerklasse beschreibt.
Beispiel
// cliext_hash_map_generic_value.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// construct a generic container
Myhash_map::generic_container^ gc1 = %c1;
for each (Myhash_map::value_type elem in gc1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// get an element and display it
Myhash_map::generic_iterator gcit = gc1->begin();
Myhash_map::generic_value gcval = *gcit;
System::Console::WriteLine("[{0} {1}] ", gcval->first, gcval->second);
return (0);
}
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1]
hash_map::hash_delegate
Sucht ein Element, das einem angegebenen Schlüssel entspricht.
Syntax
hasher^ hash_delegate();
Hinweise
Die Memberfunktion gibt den Delegaten zurück, der zum Konvertieren eines Schlüsselwerts in eine ganze Zahl verwendet wird. Sie verwenden es, um einen Hash für einen Schlüssel zu erstellen.
Beispiel
// cliext_hash_map_hash_delegate.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
Myhash_map::hasher^ myhash = c1.hash_delegate();
System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
return (0);
}
hash(L'a') = 1616896120
hash(L'b') = 570892832
hash_map::hash_map
Erstellt ein container-Objekt.
Syntax
hash_map();
explicit hash_map(key_compare^ pred);
hash_map(key_compare^ pred, hasher^ hashfn);
hash_map(hash_map<Key, Mapped>% right);
hash_map(hash_map<Key, Mapped>^ right);
template<typename InIter>
hash_maphash_map(InIter first, InIter last);
template<typename InIter>
hash_map(InIter first, InIter last,
key_compare^ pred);
template<typename InIter>
hash_map(InIter first, InIter last,
key_compare^ pred, hasher^ hashfn);
hash_map(System::Collections::Generic::IEnumerable<GValue>^ right);
hash_map(System::Collections::Generic::IEnumerable<GValue>^ right,
key_compare^ pred);
hash_map(System::Collections::Generic::IEnumerable<GValue>^ right,
key_compare^ pred, hasher^ hashfn);
Parameter
first
Anfang des einzufügenden Bereichs.
hashfn
Hashfunktion zum Zuordnen von Schlüsseln zu Buckets.
last
Ende des einzufügenden Bereichs.
pred
Sortieren des Prädikats für die kontrollierte Sequenz.
right
Einzufügendes Objekt bzw. einzufügender Bereich.
Hinweise
Der Konstruktor:
hash_map();
initialisiert die kontrollierte Sequenz ohne Elemente, mit dem Standardreihenfolgen-Prädikat key_compare()und mit der Standardhashfunktion. Sie verwenden es, um eine leere anfängliche kontrollierte Sequenz mit der Standardreihenfolge-Prädikat- und Hashfunktion anzugeben.
Der Konstruktor:
explicit hash_map(key_compare^ pred);
initialisiert die kontrollierte Sequenz ohne Elemente, mit dem Sortier-Prädikat predund mit der Standardhashfunktion. Sie verwenden es, um eine leere anfängliche kontrollierte Sequenz mit dem angegebenen Sortier-Prädikat und der Standardhashfunktion anzugeben.
Der Konstruktor:
hash_map(key_compare^ pred, hasher^ hashfn);
initialisiert die kontrollierte Sequenz ohne Elemente, mit dem Sortier-Prädikat predund mit der Hashfunktion hashfn. Sie verwenden es, um eine leere anfängliche kontrollierte Sequenz mit der angegebenen Sortier-Prädikat- und Hashfunktion anzugeben.
Der Konstruktor:
hash_map(hash_map<Key, Mapped>% right);
initialisiert die kontrollierte Sequenz mit der Sequenz [right.begin(), right.end()), mit dem Standardreihenfolge-Prädikat und mit der Standardhashfunktion. Sie verwenden sie, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der vom Objekt rightgesteuerten hash_map Sequenz mit der Standardreihenfolgen-Prädikat- und Hashfunktion ist.
Der Konstruktor:
hash_map(hash_map<Key, Mapped>^ right);
initialisiert die kontrollierte Sequenz mit der Sequenz [right->begin(), right->end()), mit dem Standardreihenfolge-Prädikat und mit der Standardhashfunktion. Sie verwenden sie, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der vom Objekt rightgesteuerten hash_map Sequenz mit der Standardreihenfolgen-Prädikat- und Hashfunktion ist.
Der Konstruktor:
template<typename InIter> hash_map(InIter first, InIter last);
initialisiert die kontrollierte Sequenz mit der Sequenz [first, last), mit dem Standardreihenfolge-Prädikat und mit der Standardhashfunktion. Sie verwenden sie, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz mit der Standardreihenfolge-Prädikat- und Hashfunktion zu machen.
Der Konstruktor:
template<typename InIter> hash_map(InIter first, InIter last, key_compare^ pred);
initialisiert die kontrollierte Sequenz mit der Sequenz [first, last), mit dem Sortier-Prädikat predund mit der Standardhashfunktion. Sie verwenden sie, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz mit dem angegebenen Sortier-Prädikat und der Standardhashfunktion zu machen.
Der Konstruktor:
template<typename InIter> hash_map(InIter first, InIter last, key_compare^ pred, hasher^ hashfn);
initialisiert die kontrollierte Sequenz mit der Sequenz [first, last), mit dem Sortier-Prädikat predund mit der Hashfunktion hashfn. Sie verwenden sie, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz mit der angegebenen Sortier-Prädikat- und Hashfunktion zu machen.
Der Konstruktor:
hash_map(System::Collections::Generic::IEnumerable<Key>^ right);
initialisiert die kontrollierte Sequenz mit der vom Enumerator rightfestgelegten Sequenz, mit dem Standardreihenfolgen-Prädikat und mit der Standardhashfunktion. Sie verwenden sie, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz zu machen, die von einem Enumerator beschrieben wird, mit der Standardreihenfolgen-Prädikat- und Hashfunktion.
Der Konstruktor:
hash_map(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred);
initialisiert die kontrollierte Sequenz mit der sequenz, die vom Enumerator rightbestimmt ist, mit dem Sortier-Prädikat predund der Standardhashfunktion. Sie verwenden sie, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz zu machen, die von einem Enumerator mit der angegebenen Sortiervorschrift und der Standardhashfunktion beschrieben wird.
Der Konstruktor:
hash_map(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred, hasher^ hashfn);
initialisiert die kontrollierte Sequenz mit der sequenz, die vom Enumerator rightbestimmt wird, mit dem Sortier-Prädikat predund mit der Hashfunktion hashfn. Sie verwenden sie, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz zu machen, die von einem Enumerator mit der angegebenen Sortier-Prädikat- und Hashfunktion beschrieben wird.
Beispiel
// cliext_hash_map_construct.cpp
// compile with: /clr
#include <cliext/hash_map>
int myfun(wchar_t key)
{ // hash a key
return (key ^ 0xdeadbeef);
}
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
// construct an empty container
Myhash_map c1;
System::Console::WriteLine("size() = {0}", c1.size());
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// construct with an ordering rule
Myhash_map c2 = cliext::greater_equal<wchar_t>();
System::Console::WriteLine("size() = {0}", c2.size());
c2.insert(c1.begin(), c1.end());
for each (Myhash_map::value_type elem in c2)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// construct with an ordering rule and hash function
Myhash_map c2h(cliext::greater_equal<wchar_t>(),
gcnew Myhash_map::hasher(&myfun));
System::Console::WriteLine("size() = {0}", c2h.size());
c2h.insert(c1.begin(), c1.end());
for each (Myhash_map::value_type elem in c2h)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
System::Console::WriteLine();
// construct with an iterator range
Myhash_map c3(c1.begin(), c1.end());
for each (Myhash_map::value_type elem in c3)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// construct with an iterator range and an ordering rule
Myhash_map c4(c1.begin(), c1.end(),
cliext::greater_equal<wchar_t>());
for each (Myhash_map::value_type elem in c4)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// construct with an iterator range and an ordering rule and hash function
Myhash_map c4h(c1.begin(), c1.end(),
cliext::greater_equal<wchar_t>(),
gcnew Myhash_map::hasher(&myfun));
for each (Myhash_map::value_type elem in c4h)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
System::Console::WriteLine();
// construct with an enumeration
Myhash_map c5( // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<
Myhash_map::value_type>^)%c3);
for each (Myhash_map::value_type elem in c5)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// construct with an enumeration and an ordering rule
Myhash_map c6( // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<
Myhash_map::value_type>^)%c3,
cliext::greater_equal<wchar_t>());
for each (Myhash_map::value_type elem in c6)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// construct with an enumeration and an ordering rule and hash function
Myhash_map c6h( // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<
Myhash_map::value_type>^)%c3,
cliext::greater_equal<wchar_t>(),
gcnew Myhash_map::hasher(&myfun));
for each (Myhash_map::value_type elem in c6h)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
System::Console::WriteLine();
// construct by copying another container
Myhash_map c7(c4);
for each (Myhash_map::value_type elem in c7)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// construct by copying a container handle
Myhash_map c8(%c3);
for each (Myhash_map::value_type elem in c8)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
return (0);
}
size() = 0
[a 1] [b 2] [c 3]
size() = 0
[a 1] [b 2] [c 3]
size() = 0
[c 3] [b 2] [a 1]
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[c 3] [b 2] [a 1]
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[c 3] [b 2] [a 1]
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
hash_map::hasher
Der Hashingdelegat für einen Schlüssel.
Syntax
Microsoft::VisualC::StlClr::UnaryDelegate<GKey, int>
hasher;
Hinweise
Der Typ beschreibt einen Delegaten, der einen Schlüsselwert in eine ganze Zahl konvertiert.
Beispiel
// cliext_hash_map_hasher.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
Myhash_map::hasher^ myhash = c1.hash_delegate();
System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
return (0);
}
hash(L'a') = 1616896120
hash(L'b') = 570892832
hash_map::insert
Fügt Elemente hinzu.
Syntax
cliext::pair<iterator, bool> insert(value_type val);
iterator insert(iterator where, value_type val);
template<typename InIter>
void insert(InIter first, InIter last);
void insert(System::Collections::Generic::IEnumerable<value_type>^ right);
Parameter
first
Anfang des einzufügenden Bereichs.
last
Ende des einzufügenden Bereichs.
right
Einzufügende Aufzählung.
val
Schlüsselwert, der eingefügt werden soll.
where
Wo im Container eingefügt werden soll (nur Hinweis).
Hinweise
Jede Elementfunktion fügt eine von den verbleibenden Operanden angegebene Sequenz ein.
Die erste Memberfunktion bemüht sich, ein Element mit Wert valeinzufügen und ein Wertepaar Xzurückgibt. Ist X.second "true", X.first wird das neu eingefügte Element festgelegt. Andernfalls X.first wird ein Element mit entsprechender Sortierung festgelegt, die bereits vorhanden ist und kein neues Element eingefügt wird. Sie verwenden es, um ein einzelnes Element einzufügen.
Die zweite Memberfunktion fügt ein Element mit Einem Wert valein, verwendet where als Hinweis (zur Verbesserung der Leistung), und gibt einen Iterator zurück, der das neu eingefügte Element angibt. Sie verwenden es, um ein einzelnes Element einzufügen, das sich möglicherweise neben einem Element befindet, das Sie kennen.
Die dritte Memberfunktion fügt die Sequenz [first, last) ein. Sie verwenden es, um null oder mehr Elemente einzufügen, die aus einer anderen Sequenz kopiert wurden.
Die vierte Memberfunktion fügt die durch die right. Sie verwenden sie, um eine von einem Enumerator beschriebene Sequenz einzufügen.
Jedes Elementeinfügung benötigt Zeit proportional zum Logarithmus der Anzahl der Elemente in der kontrollierten Sequenz. Das Einfügen kann in amortisierter Konstantenzeit erfolgen, jedoch mit einem Hinweis, der ein Element neben der Einfügemarke angibt.
Beispiel
// cliext_hash_map_insert.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
typedef Myhash_map::pair_iter_bool Pairib;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// insert a single value, unique and duplicate
Pairib pair1 =
c1.insert(Myhash_map::make_value(L'x', 24));
System::Console::WriteLine("insert([L'x' 24]) = [{0} {1}] {2}",
pair1.first->first, pair1.first->second, pair1.second);
pair1 = c1.insert(Myhash_map::make_value(L'b', 2));
System::Console::WriteLine("insert([L'b' 2]) = [{0} {1}] {2}",
pair1.first->first, pair1.first->second, pair1.second);
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// insert a single value with hint
Myhash_map::iterator it =
c1.insert(c1.begin(), Myhash_map::make_value(L'y', 25));
System::Console::WriteLine("insert(begin(), [L'y' 25]) = [{0} {1}]",
it->first, it->second);
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// insert an iterator range
Myhash_map c2;
it = c1.end();
c2.insert(c1.begin(), --it);
for each (Myhash_map::value_type elem in c2)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// insert an enumeration
Myhash_map c3;
c3.insert( // NOTE: cast is not needed
(System::Collections::Generic::
IEnumerable<Myhash_map::value_type>^)%c1);
for each (Myhash_map::value_type elem in c3)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]
insert([L'x' 24]) = [x 24] True
insert([L'b' 2]) = [b 2] False
[a 1] [b 2] [c 3] [x 24]
insert(begin(), [L'y' 25]) = [y 25]
[a 1] [b 2] [c 3] [x 24] [y 25]
[a 1] [b 2] [c 3] [x 24]
[a 1] [b 2] [c 3] [x 24] [y 25]
hash_map::iterator
Der Typ eines Iterators für die gesteuerte Sequenz.
Syntax
typedef T1 iterator;
Hinweise
Der Typ beschreibt ein Objekt nicht angegebener Typs T1 , das als bidirektionaler Iterator für die kontrollierte Sequenz dienen kann.
Beispiel
// cliext_hash_map_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
Myhash_map::iterator it = c1.begin();
for (; it != c1.end(); ++it)
System::Console::Write("[{0} {1}] ", it->first, it->second);
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]
hash_map::key_comp
Kopiert den Sortierdelegat für zwei Schlüssel.
Syntax
key_compare^key_comp();
Hinweise
Die Memberfunktion gibt den Sortierdelegat zurück, der zum Sortieren der gesteuerten Sequenz verwendet wird. Sie verwenden es, um zwei Tasten zu vergleichen.
Beispiel
// cliext_hash_map_key_comp.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
Myhash_map::key_compare^ kcomp = c1.key_comp();
System::Console::WriteLine("compare(L'a', L'a') = {0}",
kcomp(L'a', L'a'));
System::Console::WriteLine("compare(L'a', L'b') = {0}",
kcomp(L'a', L'b'));
System::Console::WriteLine("compare(L'b', L'a') = {0}",
kcomp(L'b', L'a'));
System::Console::WriteLine();
// test a different ordering rule
Myhash_map c2 = cliext::greater<wchar_t>();
kcomp = c2.key_comp();
System::Console::WriteLine("compare(L'a', L'a') = {0}",
kcomp(L'a', L'a'));
System::Console::WriteLine("compare(L'a', L'b') = {0}",
kcomp(L'a', L'b'));
System::Console::WriteLine("compare(L'b', L'a') = {0}",
kcomp(L'b', L'a'));
return (0);
}
compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False
compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True
hash_map::key_compare
Der Sortierdelegat für zwei Schlüssel.
Syntax
Microsoft::VisualC::StlClr::BinaryDelegate<GKey, GKey, bool>
key_compare;
Hinweise
Der Typ ist ein Synonym für den Delegaten, der die Sortierung seiner Schlüsselargumente bestimmt.
Beispiel
// cliext_hash_map_key_compare.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
Myhash_map::key_compare^ kcomp = c1.key_comp();
System::Console::WriteLine("compare(L'a', L'a') = {0}",
kcomp(L'a', L'a'));
System::Console::WriteLine("compare(L'a', L'b') = {0}",
kcomp(L'a', L'b'));
System::Console::WriteLine("compare(L'b', L'a') = {0}",
kcomp(L'b', L'a'));
System::Console::WriteLine();
// test a different ordering rule
Myhash_map c2 = cliext::greater<wchar_t>();
kcomp = c2.key_comp();
System::Console::WriteLine("compare(L'a', L'a') = {0}",
kcomp(L'a', L'a'));
System::Console::WriteLine("compare(L'a', L'b') = {0}",
kcomp(L'a', L'b'));
System::Console::WriteLine("compare(L'b', L'a') = {0}",
kcomp(L'b', L'a'));
return (0);
}
compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False
compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True
hash_map::key_type
Der Typ eines Sortierschlüssels.
Syntax
typedef Key key_type;
Hinweise
Der Type stellt ein Synonym für den Vorlagenparameter Keydar.
Beispiel
// cliext_hash_map_key_type.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]" using key_type
for (Myhash_map::iterator it = c1.begin(); it != c1.end(); ++it)
{ // store element in key_type object
Myhash_map::key_type val = it->first;
System::Console::Write("{0} ", val);
}
System::Console::WriteLine();
return (0);
}
a b c
hash_map::load_factor
Zählt die durchschnittliche Anzahl von Elementen pro Bucket.
Syntax
float load_factor();
Hinweise
Die Memberfunktion gibt (float)size() / bucket_count() zurück. Sie verwenden es, um die durchschnittliche Bucketgröße zu bestimmen.
Beispiel
// cliext_hash_map_load_factor.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1 = gcnew Myhash_map;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// inspect current parameters
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// change max_load_factor and redisplay
c1.max_load_factor(0.25f);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// rehash and redisplay
c1.rehash(100);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
return (0);
}
[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25
bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25
hash_map::lower_bound
Sucht den Anfang des Bereichs, der einem angegebenen Schlüssel entspricht.
Syntax
iterator lower_bound(key_type key);
Parameter
key
Der zu suchende Schlüsselwert.
Hinweise
Die Memberfunktion bestimmt das erste Element X in der gesteuerten Sequenz, das hashet auf denselben Bucket key und weist eine entsprechende Sortierung auf key. Wenn kein solches Element vorhanden ist, wird es zurückgegeben end(); andernfalls wird ein Iterator zurückgegeben, der dies Xangibt. Sie verwenden es, um den Anfang einer Abfolge von Elementen zu finden, die derzeit in der gesteuerten Sequenz vorhanden sind, die einem angegebenen Schlüssel entsprechen.
Beispiel
// cliext_hash_map_lower_bound.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
System::Console::WriteLine("lower_bound(L'x')==end() = {0}",
c1.lower_bound(L'x') == c1.end());
Myhash_map::iterator it = c1.lower_bound(L'a');
System::Console::WriteLine("*lower_bound(L'a') = [{0} {1}]",
it->first, it->second);
it = c1.lower_bound(L'b');
System::Console::WriteLine("*lower_bound(L'b') = [{0} {1}]",
it->first, it->second);
return (0);
}
[a 1] [b 2] [c 3]
lower_bound(L'x')==end() = True
*lower_bound(L'a') = [a 1]
*lower_bound(L'b') = [b 2]
hash_map::make_value
Erstellt ein Wertobjekt.
Syntax
static value_type make_value(key_type key, mapped_type mapped);
Parameter
key
Schlüsselwert, der verwendet werden soll.
mapped
Zugeordneter Wert, nach dem gesucht werden soll.
Hinweise
Die Memberfunktion gibt ein value_type Objekt zurück, dessen Schlüssel und key dessen zugeordneter Wert ist mapped. Sie verwenden es, um ein Objekt zu verfassen, das für die Verwendung mit mehreren anderen Memberfunktionen geeignet ist.
Beispiel
// cliext_hash_map_make_value.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]
hash_map::mapped_type
Der Typ eines zugeordneten Werts, der jedem Schlüssel zugeordnet ist.
Syntax
typedef Mapped mapped_type;
Hinweise
Der Type stellt ein Synonym für den Vorlagenparameter Mappeddar.
Beispiel
// cliext_hash_map_mapped_type.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]" using mapped_type
for (Myhash_map::iterator it = c1.begin(); it != c1.end(); ++it)
{ // store element in mapped_type object
Myhash_map::mapped_type val = it->second;
System::Console::Write("{0} ", val);
}
System::Console::WriteLine();
return (0);
}
1 2 3
hash_map::max_load_factor
Ruft die maximale Anzahl von Elementen pro Bucket ab oder legt sie fest.
Syntax
float max_load_factor();
void max_load_factor(float new_factor);
Parameter
new_factor
Neuer maximaler Ladefaktor zum Speichern.
Hinweise
Die erste Memberfunktion gibt den aktuellen gespeicherten maximalen Ladefaktor zurück. Sie verwenden es, um die maximale durchschnittliche Bucketgröße zu bestimmen.
Die zweite Memberfunktion ersetzt den speicherhöchsten Ladefaktor durch new_factor. Es tritt kein automatisches Erneutes Aufhashing auf, bis ein nachfolgendes Einfügen erfolgt.
Beispiel
// cliext_hash_map_max_load_factor.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1 = gcnew Myhash_map;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// inspect current parameters
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// change max_load_factor and redisplay
c1.max_load_factor(0.25f);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// rehash and redisplay
c1.rehash(100);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
return (0);
}
[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25
bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25
hash_map::operator=
Ersetzt die kontrollierte Sequenz.
Syntax
hash_map<Key, Mapped>% operator=(hash_map<Key, Mapped>% right);
Parameter
right
Der zu kopierende Container.
Hinweise
Der Memberoperator kopiert right in das Objekt und gibt dann zurück *this. Sie können ihn verwenden, um die kontrollierte Sequenz durch eine Kopie der kontrollierten Sequenz in right zu ersetzen.
Beispiel
// cliext_hash_map_operator_as.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// assign to a new container
Myhash_map c2;
c2 = c1;
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c2)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
hash_map::operator[]
Ordnet einen Schlüssel dem zugeordneten zugeordneten Wert zu.
Syntax
mapped_type operator[](key_type key);
Parameter
key
Der zu suchende Schlüsselwert.
Hinweise
Die Memberfunktionen bemühen sich, ein Element mit entsprechender Reihenfolge keyzu finden. Wenn ein Wert gefunden wird, wird der zugeordnete zugeordnete Wert zurückgegeben. andernfalls wird der zugeordnete (Standard)zugeordnete Wert eingefügt value_type(key, mapped_type()) und zurückgegeben. Sie verwenden ihn, um einen zugeordneten Wert anhand des zugeordneten Schlüssels nachzuschlagen, oder um sicherzustellen, dass ein Eintrag für den Schlüssel vorhanden ist, wenn keine gefunden wird.
Beispiel
// cliext_hash_map_operator_sub.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
System::Console::WriteLine("c1[{0}] = {1}",
L'A', c1[L'A']);
System::Console::WriteLine("c1[{0}] = {1}",
L'b', c1[L'b']);
// redisplay altered contents
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// alter mapped values and redisplay
c1[L'A'] = 10;
c1[L'c'] = 13;
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]
c1[A] = 0
c1[b] = 2
[a 1] [A 0] [b 2] [c 3]
[a 1] [A 10] [b 2] [c 13]
hash_map::rbegin
Legt den Anfang der umgekehrten kontrollierten Sequenz fest.
Syntax
reverse_iterator rbegin();
Hinweise
Die Memberfunktion gibt einen Umgekehrten Iterator zurück, der das letzte Element der gesteuerten Sequenz oder direkt hinter dem Anfang einer leeren Sequenz angibt. Daher wird die beginning umgekehrte Sequenz festgelegt. Sie verwenden es, um einen Iterator zu erhalten, der den current Anfang der kontrollierten Sequenz angibt, die in umgekehrter Reihenfolge angezeigt wird, aber sein Status kann sich ändern, wenn sich die Länge der kontrollierten Sequenz ändert.
Beispiel
// cliext_hash_map_rbegin.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// inspect first two items in reversed sequence
Myhash_map::reverse_iterator rit = c1.rbegin();
System::Console::WriteLine("*rbegin() = [{0} {1}]",
rit->first, rit->second);
++rit;
System::Console::WriteLine("*++rbegin() = [{0} {1}]",
rit->first, rit->second);
return (0);
}
[a 1] [b 2] [c 3]
*rbegin() = [c 3]
*++rbegin() = [b 2]
hash_map::reference
Der Typ eines Verweises auf ein Element.
Syntax
typedef value_type% reference;
Hinweise
Der Typ beschreibt einen Verweis auf ein Element.
Beispiel
// cliext_hash_map_reference.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
Myhash_map::iterator it = c1.begin();
for (; it != c1.end(); ++it)
{ // get a reference to an element
Myhash_map::reference ref = *it;
System::Console::Write("[{0} {1}] ", ref->first, ref->second);
}
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]
hash_map::rehash
Erstellt die Hashtabelle neu.
Syntax
void rehash();
Hinweise
Die Memberfunktion erstellt die Hashtabelle neu und stellt sicher, dass load_factor() <= max_load_factor(). Andernfalls erhöht sich die Hashtabelle nur nach Bedarf nach der Einfügung. (Die Größe wird nie automatisch verringert.) Sie verwenden es, um die Größe der Hashtabelle anzupassen.
Beispiel
// cliext_hash_map_rehash.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1 = gcnew Myhash_map;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// inspect current parameters
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// change max_load_factor and redisplay
c1.max_load_factor(0.25f);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// rehash and redisplay
c1.rehash(100);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
return (0);
}
[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25
bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25
hash_map::rend
Legt das Ende der umgekehrten kontrollierten Sequenz fest.
Syntax
reverse_iterator rend();
Hinweise
Die Memberfunktion gibt einen Umgekehrten Iterator zurück, der unmittelbar über den Anfang der gesteuerten Sequenz verweist. Daher wird die end umgekehrte Sequenz festgelegt. Sie verwenden es, um einen Iterator zu erhalten, der das current Ende der kontrollierten Sequenz angibt, die in umgekehrter Reihenfolge angezeigt wird, aber sein Status kann sich ändern, wenn sich die Länge der kontrollierten Sequenz ändert.
Beispiel
// cliext_hash_map_rend.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// inspect first two items in reversed sequence
Myhash_map::reverse_iterator rit = c1.rend();
--rit;
--rit;
System::Console::WriteLine("*-- --rend() = [{0} {1}]",
rit->first, rit->second);
++rit;
System::Console::WriteLine("*--rend() = [{0} {1}]",
rit->first, rit->second);
return (0);
}
[a 1] [b 2] [c 3]
*-- --rend() = [b 2]
*--rend() = [a 1]
hash_map::reverse_iterator
Der Typ eines umgekehrten Iterators für die gesteuerte Sequenz.
Syntax
typedef T3 reverse_iterator;
Hinweise
Der Typ beschreibt ein Objekt nicht angegebener Typs T3 , das als Umgekehrter Iterator für die kontrollierte Sequenz dienen kann.
Beispiel
// cliext_hash_map_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]" reversed
Myhash_map::reverse_iterator rit = c1.rbegin();
for (; rit != c1.rend(); ++rit)
System::Console::Write("[{0} {1}] ", rit->first, rit->second);
System::Console::WriteLine();
return (0);
}
[c 3] [b 2] [a 1]
hash_map::size
Ermittelt die Anzahl von Elementen.
Syntax
size_type size();
Hinweise
Die Memberfunktion gibt die Länge der gesteuerten Sequenz zurück. Sie verwenden es, um die Anzahl der Elemente zu bestimmen, die sich derzeit in der kontrollierten Sequenz befindet. Wenn Sie sich nur darum kümmern, ob die Sequenz eine Nichtzerogröße aufweist, lesen Sie hash_map::empty.
Beispiel
// cliext_hash_map_size.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0} after clearing", c1.size());
// add elements and clear again
c1.insert(Myhash_map::make_value(L'd', 4));
c1.insert(Myhash_map::make_value(L'e', 5));
System::Console::WriteLine("size() = {0} after adding 2", c1.size());
return (0);
}
[a 1] [b 2] [c 3]
size() = 0 after clearing
size() = 2 after adding 2
hash_map::size_type
Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
Syntax
typedef int size_type;
Hinweise
Der Typ beschreibt eine nicht negative Elementanzahl.
Beispiel
// cliext_hash_map_size_type.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// compute positive difference
Myhash_map::size_type diff = 0;
for (Myhash_map::iterator it = c1.begin(); it != c1.end(); ++it)
++diff;
System::Console::WriteLine("end()-begin() = {0}", diff);
return (0);
}
[a 1] [b 2] [c 3]
end()-begin() = 3
hash_map::swap
Vertauscht den Inhalt von zwei Containern.
Syntax
void swap(hash_map<Key, Mapped>% right);
Parameter
right
Container für den Tausch von Inhalten.
Hinweise
Die Memberfunktion tauscht die kontrollierten Sequenzen zwischen this und right aus. Dies geschieht in konstanter Zeit und löst keine Ausnahmen aus. Sie verwenden es als schnelle Möglichkeit, den Inhalt von zwei Containern auszutauschen.
Beispiel
// cliext_hash_map_swap.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// construct another container with repetition of values
Myhash_map c2;
c2.insert(Myhash_map::make_value(L'd', 4));
c2.insert(Myhash_map::make_value(L'e', 5));
c2.insert(Myhash_map::make_value(L'f', 6));
for each (Myhash_map::value_type elem in c2)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// swap and redisplay
c1.swap(c2);
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
for each (Myhash_map::value_type elem in c2)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]
[d 4] [e 5] [f 6]
[d 4] [e 5] [f 6]
[a 1] [b 2] [c 3]
hash_map::to_array
Kopiert die kontrollierte Sequenz in ein neues Array.
Syntax
cli::array<value_type>^ to_array();
Hinweise
Die Memberfunktion gibt ein Array zurück, das die kontrollierte Sequenz enthält. Sie verwenden es, um eine Kopie der kontrollierten Sequenz in Arrayform abzurufen.
Beispiel
// cliext_hash_map_to_array.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// copy the container and modify it
cli::array<Myhash_map::value_type>^ a1 = c1.to_array();
c1.insert(Myhash_map::make_value(L'd', 4));
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
// display the earlier array copy
for each (Myhash_map::value_type elem in a1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3] [d 4]
[a 1] [b 2] [c 3]
hash_map::upper_bound
Sucht das Ende des Bereichs, der einem angegebenen Schlüssel entspricht.
Syntax
iterator upper_bound(key_type key);
Parameter
key
Der zu suchende Schlüsselwert.
Hinweise
Die Memberfunktion bestimmt das letzte Element X in der kontrollierten Sequenz, das auf denselben Bucket hashet und key die entsprechende Sortierung aufweist key. Wenn kein solches Element vorhanden ist oder wenn X es sich um das letzte Element in der kontrollierten Sequenz handelt, wird es zurückgegeben end(); andernfalls wird ein Iterator zurückgegeben, der das erste Element überschreitet X. Sie verwenden es, um das Ende einer Abfolge von Elementen zu finden, die derzeit in der kontrollierten Sequenz vorhanden sind, die einem angegebenen Schlüssel entsprechen.
Beispiel
// cliext_hash_map_upper_bound.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]"
for each (Myhash_map::value_type elem in c1)
System::Console::Write("[{0} {1}] ", elem->first, elem->second);
System::Console::WriteLine();
System::Console::WriteLine("upper_bound(L'x')==end() = {0}",
c1.upper_bound(L'x') == c1.end());
Myhash_map::iterator it = c1.upper_bound(L'a');
System::Console::WriteLine("*upper_bound(L'a') = [{0} {1}]",
it->first, it->second);
it = c1.upper_bound(L'b');
System::Console::WriteLine("*upper_bound(L'b') = [{0} {1}]",
it->first, it->second);
return (0);
}
[a 1] [b 2] [c 3]
upper_bound(L'x')==end() = True
*upper_bound(L'a') = [b 2]
*upper_bound(L'b') = [c 3]
hash_map::value_comp
Kopiert den Sortierdelegat für zwei Elementwerte.
Syntax
value_compare^ value_comp();
Hinweise
Die Memberfunktion gibt den Sortierdelegat zurück, der zum Sortieren der gesteuerten Sequenz verwendet wird. Sie verwenden es, um zwei Elementwerte zu vergleichen.
Beispiel
// cliext_hash_map_value_comp.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
Myhash_map::value_compare^ kcomp = c1.value_comp();
System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
kcomp(Myhash_map::make_value(L'a', 1),
Myhash_map::make_value(L'a', 1)));
System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
kcomp(Myhash_map::make_value(L'a', 1),
Myhash_map::make_value(L'b', 2)));
System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
kcomp(Myhash_map::make_value(L'b', 2),
Myhash_map::make_value(L'a', 1)));
System::Console::WriteLine();
return (0);
}
compare([L'a', 1], [L'a', 1]) = True
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False
hash_map::value_compare
Der Sortierdelegat für zwei Elementwerte.
Syntax
Microsoft::VisualC::StlClr::BinaryDelegate<generic_value, generic_value, bool>
value_compare;
Hinweise
Der Typ ist ein Synonym für den Delegaten, der die Sortierung seiner Wertargumente bestimmt.
Beispiel
// cliext_hash_map_value_compare.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
Myhash_map::value_compare^ kcomp = c1.value_comp();
System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
kcomp(Myhash_map::make_value(L'a', 1),
Myhash_map::make_value(L'a', 1)));
System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
kcomp(Myhash_map::make_value(L'a', 1),
Myhash_map::make_value(L'b', 2)));
System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
kcomp(Myhash_map::make_value(L'b', 2),
Myhash_map::make_value(L'a', 1)));
System::Console::WriteLine();
return (0);
}
compare([L'a', 1], [L'a', 1]) = True
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False
hash_map::value_type
Der Typ eines Elements.
Syntax
typedef generic_value value_type;
Hinweise
Der Typ ist ein Synonym für generic_value.
Beispiel
// cliext_hash_map_value_type.cpp
// compile with: /clr
#include <cliext/hash_map>
typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
{
Myhash_map c1;
c1.insert(Myhash_map::make_value(L'a', 1));
c1.insert(Myhash_map::make_value(L'b', 2));
c1.insert(Myhash_map::make_value(L'c', 3));
// display contents " [a 1] [b 2] [c 3]" using value_type
for (Myhash_map::iterator it = c1.begin(); it != c1.end(); ++it)
{ // store element in value_type object
Myhash_map::value_type val = *it;
System::Console::Write("[{0} {1}] ", val->first, val->second);
}
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]