hash_map-Klasse

Speichert Daten und ruft sie schnell aus einer Auflistung ab, in der jedes Element ein Paar ist, das einen Sortierschlüssel aufweist, dessen Wert eindeutig und ein zugeordneter Datenwert ist.

Syntax

template <class Key,
    class Type,
    class Traits=hash_compare<Key, less<Key>>,
    class Allocator=allocator<pair <const Key, Type>>>
class hash_map

Parameter

Key
Der Schlüsseldatentyp, der in der hash_mapDatei gespeichert werden soll.

Type
Der in hash_map zu speichernde Elementdatentyp.

Traits
Der Typ, der zwei Funktionsobjekte enthält, einer der Klassenabgleiche, die zwei Elementwerte als Sortierschlüssel vergleichen können, um ihre relative Reihenfolge und eine Hashfunktion zu bestimmen, bei der es sich um einen unären Prädikatzuordnungsschlüsselwerte der Elemente handelt, um nicht signierte ganzzahlen des Typs size_tzu bestimmen. Dieses Argument ist optional und hash_compare<Key, less<Key>> der Standardwert.

Allocator
Der Typ, der das gespeicherte Allocatorobjekt darstellt, das Details zur hash_mapZuordnung und Zuordnung des Speichers kapselt. Dieses Argument ist optional, und der Standardwert ist allocator<pair <const Key, Type>>.

Hinweise

Für den hash_map gilt Folgendes:

• Ein assoziativer Container, der ein Container variabler Größe ist, der den effizienten Abruf von Elementwerten auf Grundlage eines zugeordneten Schlüsselwert unterstützt.

• Umkehrbar, da ein bidirektionaler Iterator für den Zugriff auf die Elemente bereitgestellt wird.

• Gehasht, da die Elemente auf Grundlage des Werts einer Hashfunktion, die auf die Schlüsselwerte der Elemente angewendet wird, in Buckets gruppiert werden.

• Insofern eindeutig, da jedes der Elemente einen eindeutigen Schlüssel aufweisen muss.

• Ein Paar assoziativer Container, da sich die Elementdatenwerte von den Schlüsselwerten unterscheiden.

• Eine Klassenvorlage, da die bereitgestellte Funktionalität generisch und so unabhängig vom spezifischen Datentyp ist, der als Elemente oder Schlüssel enthalten ist. Die für Elemente und Schlüssel zu verwendenden Datentypen werden stattdessen in der Klassenvorlage zusammen mit der Vergleichsfunktion und der Zuweisung als Parameter angegeben.

Der Hauptvorteil des Hashverfahrens gegenüber der Sortierung ist die größere Effizienz. Bei einem erfolgreichen Hashverfahren werden Einfüge-, Lösch- und Suchvorgänge, verglichen mit einer Zeit, die zum Logarithmus der Anzahl von Elementen im Container für Sortiertechniken proportional ist, in einer konstanten Durchschnittszeit durchgeführt. Der Wert eines Elements in einem hash_map, aber nicht dessen zugeordnetem Schlüsselwert kann direkt geändert werden. Stattdessen müssen die Schlüsselwerte, die alten Elementen zugeordnet sind, gelöscht, und stattdessen neuen Schlüsselwerten für neue Elemente zugeordnet werden.

Die Auswahl des Containertyps sollte im Allgemeinen auf Grundlage des für die Anwendung erforderlichen Suchen und Einfügetyps erfolgen. Gehashte assoziative Container sind für Such-, Einfüge- und Entfernvorgänge optimiert. Die Memberfunktionen, die diese Vorgänge explizit unterstützen, sind effizient, wenn sie mit einer gut entworfenen Hashfunktion verwendet werden. Dann werden sie in einer Zeit ausgeführt, die im Durchschnitt konstant und nicht von der Anzahl von Elementen im Container abhängig ist. Eine ausgereifte Hashfunktion erzeugt eine vereinheitlichte Verteilung gehashter Werte und minimiert die Anzahl von Konflikten, bei denen ein Konflikt vorhergesagt wird, wenn unterschiedliche Schlüsselwerte dem gleichen gehashten Wert zugeordnet werden. Im schlimmsten Fall ist die Anzahl von Vorgängen bei der schlimmstmöglichen Hashfunktion zu der Anzahl von Elementen in der Sequenz proportional (lineare Zeit).

Dies hash_map sollte der assoziative Container der Wahl sein, wenn die Bedingungen, die die Werte mit ihren Schlüsseln verknüpfen, von der Anwendung erfüllt werden. Ein Modell für diesen Strukturtyp ist eine geordnete Liste eindeutig auftretender Schlüsselwörter mit zugeordneten Zeichenfolgewerten, die etwa Definitionen bereitstellen. Wenn die Wörter stattdessen mehr als eine richtige Definition hatten, sodass Schlüssel nicht eindeutig waren, wäre ein hash_multimap Container der Wahl. Wenn dagegen nur die Liste der Wörter gespeichert wurde, wäre ein hash_set Container der richtige. Wenn mehrere Vorkommen der Wörter zulässig wären, wäre eine hash_multiset die entsprechende Containerstruktur.

Die hash_map Reihenfolge, die sie steuert, wird durch Aufrufen eines gespeicherten Hashobjekts Traits der Klasse value_comparesortiert. Auf dieses gespeicherte Objekt kann durch Aufrufen der Memberfunktion key_compzugegriffen werden. Ein solches Funktionsobjekt muss sich wie ein Objekt der Klasse hash_compare<Key, less<Key>>verhalten. Insbesondere für alle Key-Werte des Typs Key erreicht der Traits-Aufruf ( Key ) eine Verteilung der Werte vom Typ size_t. Weitere Informationen finden Sie unter hash_compare.

Im Allgemeinen müssen die Elemente nur kleiner als vergleichbar sein, um diese Reihenfolge festzulegen: sodass aufgrund von zwei Elementen entweder festgestellt werden kann, dass sie gleichwertig sind (im Sinne, dass keines kleiner als der andere ist) oder dass ein Element kleiner als der andere ist. Dies führt zu einer Sortierung zwischen den nicht gleichwertigen Elementen. Etwas technischer betrachtet ist die Vergleichsfunktion ein binäres Prädikat, das eine strenge schwache Sortierung im mathematischen Sinn verursacht. Bei einem binären f(x y)--Prädikat handelt es sich um ein Funktionsobjekt, das die zwei Argumentobjekte x und y aufweist sowie einen Rückgabewert von true oder false. Eine sortierung, die für eine ist hash_map eine strenge schwache Reihenfolge, wenn das binäre Prädikat irreflexiv, antisymmetrisch und transitiv ist und wenn Äquivalenz transitiv ist, wobei zwei Objekte x y und definiert sind, die gleich sind, wenn sowohl f(x, y) als auch f(y, x) sind false. Wenn der stärkere Gleichheitszustand zwischen Schlüsseln die Äquivalenz ersetzt, erfolgt die Sortierung total (d. h., alle Elemente werden zueinander sortiert), und die verglichenen Schlüssel sind von den einander nicht mehr zu unterscheiden.

Die tatsächliche Reihenfolge der Elemente in der gesteuerten Sequenz hängt von der Hashfunktion, der Sortierfunktion und der aktuellen Größe der Hashtabelle ab, die im Containerobjekt gespeichert wird. Sie können die aktuelle Größe der Hashtabelle nicht ermitteln, sodass Sie die Reihenfolge der Elemente in der kontrollierten Sequenz nicht im Allgemeinen vorhersagen können. Das Einfügen von Elementen führt nicht dazu, dass Iteratoren ungültig werden, und durch das Entfernen von Elementen werden nur solche Iteratoren ungültig, die speziell auf die entfernten Elemente gezeigt haben.

Der von der hash_map Klasse bereitgestellte Iterator ist ein bidirektionaler Iterator, aber die Klassenmemberfunktionen insert und hash_map verfügen über Versionen, die als Vorlagenparameter einen schwächeren Eingabe-Iterator verwenden, dessen Funktionalitätsanforderungen minimaler sind als die von der Klasse bidirektionaler Iteratoren garantierten. Die verschiedenen Iteratorkonzepte bilden eine Family, die durch Verfeinerungen in ihrer Funktionen verknüpft ist. Jedes Iteratorkonzept weist einen eigenen Satz von Anforderungen auf, und die damit funktionierenden Algorithmen müssen die Annahmen hinsichtlich der von diesem Iteratortyp bereitgestellten Anforderungen begrenzen. Es kann davon ausgegangen werden, dass ein Eingabeiterator möglicherweise so dereferenziert wird, dass er auf ein Objekt verweist und dieses möglicherweise zum folgenden Iterator in der Sequenz erhöht. Dies ist ein minimaler Satz von Funktionen, aber es reicht aus, sinnvoll über einen Bereich von Iteratoren [First, Last) im Kontext der Klassenmemberfunktionen zu sprechen.

Konstruktoren

Konstruktor	Beschreibung
hash_map	Erstellt ein hash_map-Element, das leer oder die Kopie eines ganzen anderen hash_map-Elements oder eines Teils davon ist.

TypeDefs

Typname	Beschreibung
allocator_type	Ein Typ, der die allocator-Klassentyp für das hash_map-Objekt darstellt.
const_iterator	Ein Typ, der einen bidirektionalen Iterator bereitstellt, der im const-Element ein hash_map-Element lesen kann.
const_pointer	Ein Typ, der einen Zeiger auf ein const-Element in einem hash_map-Element bereitstellt.
const_reference	Ein Typ, der einen Verweis auf ein const-Element bereitstellt, das in einem hash_map-Element zum Lesen und Ausführen von const-Vorgängen gespeichert ist.
const_reverse_iterator	Ein Typ, der einen bidirektionalen Iterator bereitstellt, der im const-Element jedes hash_map-Element lesen kann.
difference_type	Ein Ganzzahltyp mit Vorzeichen, der dazu verwendet werden kann, die Anzahl von Elementen eines hash_map-Elements in einen Bereich zwischen Elementen darzustellen, auf die von Iteratoren gezeigt wird.
iterator	Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem jedes Element in einer hash_map gelesen oder geändert werden kann.
key_compare	Eine Typ, der ein Funktionsobjekt bereitstellt, das zwei Sortierschlüssel vergleichen kann, um die relative Position von zwei Elementen im hash_map-Element zu bestimmen.
key_type	Ein Typ beschreibt das Sortierschlüsselobjekt, das jedes Element von hash_map bildet.
mapped_type	Ein Typ, der den in einer hash_map gespeicherten Datentyp darstellt.
pointer	Ein Typ, der einen Zeiger auf ein Element in einer hash_map bereitstellt.
reference	Ein Typ, der einen Verweis auf ein in einer hash_map gespeichertes Element bereitstellt.
reverse_iterator	Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem ein Element in einem umgekehrten hash_map-Element gelesen oder geändert werden kann.
size_type	Eine Ganzzahltyp ohne Vorzeichen, der die Anzahl von Elementen in hash_map darstellen kann.
value_type	Eine Typ, der ein Funktionsobjekt bereitstellt, das zwei Elemente als Sortierschlüssel vergleichen kann, um die relative Position im hash_map-Element zu bestimmen.

Memberfunktionen

Memberfunktion	Beschreibung
at	Sucht ein Element in der hash_map mit einem angegebenen Schlüsselwert.
begin	Gibt ein Iterator zurück, der das erste Element im hash_map-Element adressiert.
cbegin	Gibt einen konstanten Iterator zurück, der das erste Element im hash_map-Element adressiert.
cend	Gibt einen konstanten Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines hash_map-Elements nachfolgt.
clear	Löscht alle Elemente einer hash_map auf.
count	Gibt die Anzahl von Elementen in einem hash_map-Element zurück, dessen Schlüssel dem von einem Parameter angegebenen Schlüssel entspricht.
crbegin	Gibt einen const Iterator zurück, der das erste Element in einem umgekehrten Element adressiert hash_map.
crend	Gibt einen const Iterator zurück, der die Position adressiert, die das letzte Element in einem umgekehrten Element erfolgreich war hash_map.
emplace	Fügt ein Element ein, das vor Ort in ein hash_map-Element erstellt wird.
emplace_hint	Fügt ein Element ein, das vor Ort mit einem Platzierungshinweis in ein hash_map-Element erstellt wird.
empty	Testet, ob ein hash_map-Element leer ist.
end	Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element einem hash_map-Element nachfolgt.
equal_range	Gibt ein Iteratorpaar jeweils zum ersten Element in einem hash_map-Element mit einem Schlüssel zurück, der größer als ein bestimmter Schlüssel ist, bzw. zum ersten Element im hash_map-Element mit einem Schlüssel, der größer oder gleich dem Schlüssel ist.
erase	Entfernt ein Element oder eine Reihe von Elementen in einer hash_map aus angegebenen Speicherorten.
find	Gibt einen Iterator zurück, der die Position eines Elements in einem hash_map-Element adressiert, das einen Schlüssel aufweist, der einen angegebenen Schlüssel entspricht.
get_allocator	Gibt eine Kopie des zum Erstellen von allocator verwendeten hash_map-Objekts zurück.
insert	Fügt ein Element oder einen Elementbereich in ein hash_map-Element ein.
key_comp	Gibt einen Iterator zum ersten Element in einem hash_map-Element mit einem Schlüsselwert zurück, der gleich oder größer ist, als ein angegebener Schlüssel.
lower_bound	Gibt einen Iterator zum ersten Element in einem hash_map-Element mit einem Schlüsselwert zurück, der gleich oder größer ist, als ein angegebener Schlüssel.
max_size	Gibt die Maximallänge der hash_map zurück.
rbegin	Gibt einen Iterator zurück, der das erste Element in einem umgekehrten hash_map-Element adressiert.
rend	Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines umgekehrten hash_map-Elements nachfolgt.
size	Gibt die Anzahl von Elementen in der hash_map zurück.
swap	Tauscht die Elemente zweier hash_mapn.
upper_bound	Gibt einen Iterator zum ersten Element in einem hash_map-Element mit einem Schlüsselwert zurück, der größer ist, als ein angegebener Schlüssel.
value_comp	Ruft eine Kopie des Vergleichsobjekts ab, das zum Sortieren der Elementwerte in hash_map verwendet wird.

Operatoren

Operator	Beschreibung
operator[]	Fügt ein Element in ein hash_map-Element mit einem angegebenen Schlüsselwert ein.
hash_map::operator=	Ersetzt die Elemente eines hash_map-Elements durch eine Kopie eines anderen hash_map-Elements.

Anforderungen

Header: <hash_map>

Namespace:stdext

hash_map::allocator_type

Ein Typ, der die Zuweisungsklasse für das hash_map-Objekt darstellt.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::allocator_type allocator_type;

Beispiel

Siehe Beispiel für get_allocator ein Beispiel für die Verwendung von allocator_type.

hash_map::at

Sucht ein Element in der hash_map mit einem angegebenen Schlüsselwert.

Type& at(const Key& key);

const Type& at(const Key& key) const;

Parameter

key
Der Schlüsselwert des zu suchenden Elements.

Rückgabewert

Ein Verweis auf den Datenwert des gefundenen Elements.

Hinweise

Wenn der Argumentschlüsselwert nicht gefunden wird, löst die Funktion ein Objekt der Klassenklasse out_of_rangeaus.

Beispiel

// hash_map_at.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;

   // Insert data values
   hm1.insert ( cInt2Int ( 1, 10 ) );
   hm1.insert ( cInt2Int ( 2, 20 ) );
   hm1.insert ( cInt2Int ( 3, 30 ) );

   cout  << "The values of the mapped elements are:";
   for ( int i = 1 ; i <= hm1.size() ; i++ )
      cout << " " << hm1.at(i);
   cout << "." << endl;
}

hash_map::begin

Gibt ein Iterator zurück, der das erste Element im hash_map-Element adressiert.

const_iterator begin() const;

iterator begin();

Rückgabewert

Ein bidirektionaler Iterator, der das erste Element in der oder an der Position angibt, an der hash_map ein leerer Text ausgeführt hash_mapwird.

Beispiel

// hash_map_begin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 0, 0 ) );
   hm1.insert ( Int_Pair ( 1, 1 ) );
   hm1.insert ( Int_Pair ( 2, 4 ) );

   hm1_cIter = hm1.begin ( );
   cout << "The first element of hm1 is "
        << hm1_cIter -> first << "." << endl;

   hm1_Iter = hm1.begin ( );
   hm1.erase ( hm1_Iter );

   // The following 2 lines would err because the iterator is const
   // hm1_cIter = hm1.begin ( );
   // hm1.erase ( hm1_cIter );

   hm1_cIter = hm1.begin( );
   cout << "The first element of hm1 is now "
        << hm1_cIter -> first << "." << endl;
}

The first element of hm1 is 0.
The first element of hm1 is now 1.

hash_map::cbegin

Gibt einen konstanten Iterator zurück, der das erste Element im hash_map-Element adressiert.

const_iterator cbegin() const;

Rückgabewert

Ein paralleler bidirektionaler Iterator, der das erste Element in der oder der Position angibt, an der hash_map ein leeres Element ausgeführt hash_mapwird.

Beispiel

// hash_map_cbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 2, 4 ) );

   hm1_cIter = hm1.cbegin ( );
   cout << "The first element of hm1 is "
        << hm1_cIter -> first << "." << endl;
   }

The first element of hm1 is 2.

hash_map::cend

Gibt einen konstanten Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines hash_map-Elements nachfolgt.

const_iterator cend() const;

Rückgabewert

Ein paralleler bidirektionaler Iterator, der die Position angibt, die das letzte Element in einem hash_map. Wenn die hash_map leer ist, gilt anschließend hash_map::cend == hash_map::begin.

Hinweise

cend wird verwendet, um zu testen, ob ein Iterator das Ende seines hash_map erreicht hat.

Der zurückgegebene cend Wert sollte nicht abgeleitet werden.

Beispiel

// hash_map_cend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_cIter = hm1.cend( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is "
        << hm1_cIter -> second << "." << endl;
   }

The value of last element of hm1 is 30.

hash_map::clear

Löscht alle Elemente einer hash_map auf.

void clear();

Hinweise

Beispiel

Im folgenden Beispiel wird die Verwendung der hash_map::clear Memberfunktion veranschaulicht.

// hash_map_clear.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 1));
    hm1.insert(Int_Pair(2, 4));

    i = hm1.size();
    cout << "The size of the hash_map is initially "
         << i << "." << endl;

    hm1.clear();
    i = hm1.size();
    cout << "The size of the hash_map after clearing is "
         << i << "." << endl;
}

The size of the hash_map is initially 2.
The size of the hash_map after clearing is 0.

hash_map::const_iterator

Ein Typ, der einen bidirektionalen Iterator bereitstellt, der im const-Element ein hash_map-Element lesen kann.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_iterator const_iterator;

Hinweise

Ein Typ const_iterator kann nicht verwendet werden, um den Wert eines Elements zu ändern.

Die const_iterator durch Punkte definierten hash_map Elemente, bei denen es sich um Objekte vom value_typeTyp pair< const Key, Type >handelt , deren erstes Element der Schlüssel für das Element ist und dessen zweites Element das zugeordnete Datum ist, das vom Element gehalten wird.

Verwenden Sie den -> Operator, um ein const_iterator cIter Element in einem hash_mapElement abzuleiten.

Um auf den Wert des Schlüssels für das Element zuzugreifen, verwenden Sie cIter->firstdie Entsprechende .(*cIter).first Um auf den Wert des zugeordneten Datums für das Element zuzugreifen, verwenden Sie cIter->seconddies , was entspricht (*cIter).second.

Beispiel

Siehe Beispiel für begin ein Beispiel für die Verwendung von const_iterator.

hash_map::const_pointer

Ein Typ, der einen Zeiger auf ein const-Element in einem hash_map-Element bereitstellt.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_pointer const_pointer;

Hinweise

Ein Typ const_pointer kann nicht verwendet werden, um den Wert eines Elements zu ändern.

In den meisten Fällen sollte ein iterator Objekt verwendet werden, um auf die Elemente in einem hash_map Objekt zuzugreifen.

hash_map::const_reference

Ein Typ, der einen Verweis auf ein const-Element bereitstellt, das in einem hash_map-Element zum Lesen und Ausführen von const-Vorgängen gespeichert ist.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_reference const_reference;

Hinweise

Beispiel

// hash_map_const_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map<int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( hm1.begin( ) -> first );

   // The following line would cause an error because the
   // non-const_reference cannot be used to access the key
   // int &Ref1 = ( hm1.begin( ) -> first );

   cout << "The key of the first element in the hash_map is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( hm1.begin( ) -> second );

   cout << "The data value of the first element in the hash_map is "
        << Ref2 << "." << endl;
}

The key of the first element in the hash_map is 1.
The data value of the first element in the hash_map is 10.

hash_map::const_reverse_iterator

Ein Typ, der einen bidirektionalen Iterator bereitstellt, der im const-Element jedes hash_map-Element lesen kann.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reverse)iterator const_reverse_iterator;

Hinweise

Ein Typ const_reverse_iterator kann den Wert eines Elements nicht ändern und wird zum Durchlaufen des hash_map umgekehrten Elements verwendet.

Die const_reverse_iterator durch Punkte definierten hash_map Elemente, bei denen es sich um Objekte vom value_typeTyp pair< const Key, Type >handelt , deren erstes Element der Schlüssel für das Element ist und dessen zweites Element das zugeordnete Datum ist, das vom Element gehalten wird.

Verwenden Sie den -> Operator, um ein const_reverse_iterator crIter Element in einem hash_mapElement abzuleiten.

Um auf den Wert des Schlüssels für das Element zuzugreifen, verwenden Sie crIter->firstdie Entsprechende .(*crIter).first Um auf den Wert des zugeordneten Datums für das Element zuzugreifen, verwenden Sie crIter->seconddies , was entspricht (*crIter).first.

Beispiel

Ein Beispiel für rend das Deklarieren und Verwenden der const_reverse_iteratorDatei finden Sie im Beispiel.

hash_map::count

Gibt die Anzahl von Elementen in einem hash_map-Element zurück, dessen Schlüssel dem von einem Parameter angegebenen Schlüssel entspricht.

size_type count(const Key& key) const;

Parameter

key
Der Schlüsselwert der Elemente, die mit dem hash_mapElement abgeglichen werden sollen.

Rückgabewert

1, wenn das hash_map Element ein Element enthält, dessen Sortierschlüssel mit dem Parameterschlüssel übereinstimmt; 0, wenn das hash_map Element kein Element mit einem übereinstimmenden Schlüssel enthält.

Hinweise

Die Memberfunktion gibt die Anzahl der Elemente x im Bereich zurück.

lower_bound(key), upper_bound(key)

dies ist 0 oder 1 im Fall von hash_map, bei dem es sich um einen eindeutigen assoziativen Container handelt.

Beispiel

Im folgenden Beispiel wird die Verwendung der hash_map::count Memberfunktion veranschaulicht.

// hash_map_count.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair (1, 1));
    hm1.insert(Int_Pair (2, 1));
    hm1.insert(Int_Pair (1, 4));
    hm1.insert(Int_Pair (2, 1));

    // Keys must be unique in hash_map, so duplicates are ignored
    i = hm1.count(1);
    cout << "The number of elements in hm1 with a sort key of 1 is: "
         << i << "." << endl;

    i = hm1.count(2);
    cout << "The number of elements in hm1 with a sort key of 2 is: "
         << i << "." << endl;

    i = hm1.count(3);
    cout << "The number of elements in hm1 with a sort key of 3 is: "
         << i << "." << endl;
}

The number of elements in hm1 with a sort key of 1 is: 1.
The number of elements in hm1 with a sort key of 2 is: 1.
The number of elements in hm1 with a sort key of 3 is: 0.

hash_map::crbegin

Gibt einen const Iterator zurück, der das erste Element in einem umgekehrten Element adressiert hash_map.

const_reverse_iterator crbegin() const;

Rückgabewert

Ein const umgekehrter bidirektionaler Iterator, der das erste Element in einer umgekehrten hash_map Oder adressiert, was das letzte Element in der unreversierten hash_map.

Hinweise

crbegin wird mit einem umgekehrten hash_map verwendet, genau wie begin bei einem hash_map.

Mit dem Rückgabewert des crbeginObjekts kann das hash_map Objekt nicht geändert werden.

Mit crbegin kann ein hash_map rückwärts durchlaufen werden.

Beispiel

// hash_map_crbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_crIter = hm1.crbegin( );
   cout << "The first element of the reversed hash_map hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The first element of the reversed hash_map hm1 is 3.

hash_map::crend

Gibt einen const Iterator zurück, der die Position adressiert, die das letzte Element in einem umgekehrten Element erfolgreich war hash_map.

const_reverse_iterator crend() const;

Rückgabewert

Ein const umgekehrter bidirektionaler Iterator, der die Position adressiert, die das letzte Element in einem umgekehrten hash_map Element erfolgreich war (die Position, die dem ersten Element in der unreversierten hash_mapSeite vorausging).

Hinweise

crend wird mit einem umgekehrten hash_map verwendet, genau wie hash_map::end bei einem hash_map.

Mit dem Rückgabewert des crendObjekts kann das hash_map Objekt nicht geändert werden.

crend kann verwendet werden, um zu testen, ob das Ende der hash_map von einem umgekehrten Iterator erreicht wurde.

Der zurückgegebene crend Wert sollte nicht abgeleitet werden.

Beispiel

// hash_map_crend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_crIter = hm1.crend( );
   hm1_crIter--;
   cout << "The last element of the reversed hash_map hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The last element of the reversed hash_map hm1 is 3.

hash_map::difference_type

Ein Ganzzahltyp mit Vorzeichen, der dazu verwendet werden kann, die Anzahl von Elementen eines hash_map-Elements in einen Bereich zwischen Elementen darzustellen, auf die von Iteratoren gezeigt wird.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::difference_type difference_type;

Beispiel

// hash_map_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_map>
#include <algorithm>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 3, 20 ) );

   // The following won't insert, because map keys are unique
   hm1.insert ( Int_Pair ( 2, 30 ) );

   hash_map <int, int>::iterator hm1_Iter, hm1_bIter, hm1_eIter;
   hm1_bIter = hm1.begin( );
   hm1_eIter = hm1.end( );

   // Count the number of elements in a hash_map
   hash_map <int, int>::difference_type  df_count = 0;
   hm1_Iter = hm1.begin( );
   while ( hm1_Iter != hm1_eIter)
   {
      df_count++;
      hm1_Iter++;
   }

   cout << "The number of elements in the hash_map hm1 is: "
        << df_count << "." << endl;

   cout  << "The keys of the mapped elements are:";
   for ( hm1_Iter= hm1.begin( ) ; hm1_Iter!= hm1.end( ) ;
         hm1_Iter++)
      cout << " " << hm1_Iter-> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( hm1_Iter= hm1.begin( ) ; hm1_Iter!= hm1.end( ) ;
         hm1_Iter++)
      cout << " " << hm1_Iter-> second;
   cout << "." << endl;
}

The number of elements in the hash_map hm1 is: 3.
The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 20.

hash_map::emplace

Fügt ein Element ein, das vor Ort in ein hash_map-Element erstellt wird.

template <class ValTy>
pair <iterator, bool>
emplace(
    ValTy&& val);

Parameter

val
Der zum Verschieben des Konstrukts verwendete Wert erstellt ein Element, das in das hash_map Element eingefügt werden soll, es sei denn, das hash_map element enthält dieses Element (oder im Allgemeinen ein Element, dessen Schlüssel gleichwertig sortiert ist).

Rückgabewert

Die emplace Memberfunktion gibt ein Paar zurück, dessen bool Komponente zurückgibt true , ob eine Einfügung vorgenommen wurde und false ob das hash_map element bereits ein Element enthielt, dessen Schlüssel einen entsprechenden Wert in der Sortierung aufweist und dessen iterator Komponente die Adresse zurückgibt, an der ein neues Element eingefügt wurde oder wo sich das Element bereits befindet.

Um auf die iterator-Komponente eines pr-Paares zuzugreifen, das von dieser Memberfunktion zurückgegeben wird, verwenden Sie pr.first und *(pr.first), um es zu dereferenzieren. Um auf die bool-Komponente eines pr-Paares zuzugreifen, das von dieser Memberfunktion zurückgegeben wird, verwenden Sie pr.second und *(pr.second), um es zu dereferenzieren.

Hinweise

Das hash_map::value_type Element ist ein Paar, sodass der Wert eines Elements ein geordnetes Paar mit der ersten Komponente ist, die dem Schlüsselwert und der zweiten Komponente entspricht dem Datenwert des Elements.

Beispiel

// hash_map_emplace.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(move(is1));
    cout << "After the emplace insertion, hm1 contains:" << endl
      << " " << hm1.begin()->first
      << " => " << hm1.begin()->second
      << endl;
}

After the emplace insertion, hm1 contains:
1 => a

hash_map::emplace_hint

Fügt ein Element ein, das vor Ort mit einem Platzierungshinweis in ein hash_map-Element erstellt wird.

template <class ValTy>
iterator emplace_hint(
    const_iterator _Where,
    ValTy&& val);

Parameter

val
Der zum Verschieben des Konstrukts verwendete Wert erstellt ein Element, das in das hash_map Element eingefügt werden soll, es sei denn, das hash_map element enthält dieses Element (oder im Allgemeinen ein Element, dessen Schlüssel gleichwertig sortiert ist).

c
Ein Hinweis bezüglich des Platzes, an dem mit der Suche nach dem richtigen Einfügepunkt begonnen wird.

Rückgabewert

Die hash_multimap::emplace Memberfunktion gibt einen Iterator zurück, der auf die Position zeigt, an der das neue Element in das hash_mapElement eingefügt wurde oder wo sich das vorhandene Element mit entsprechender Reihenfolge befindet.

Hinweise

Das hash_map::value_type Element ist ein Paar, sodass der Wert eines Elements ein geordnetes Paar mit der ersten Komponente ist, die dem Schlüsselwert und der zweiten Komponente entspricht dem Datenwert des Elements.

Das Einfügen kann in amortisierter konstanter Zeit anstelle von logarithmischer Zeit erfolgen, wenn die Einfügemarke direkt auf _Where folgt.

Beispiel

// hash_map_emplace_hint.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(hm1.begin(), move(is1));
    cout << "After the emplace, hm1 contains:" << endl
      << " " << hm1.begin()->first
      << " => " << hm1.begin()->second
      << endl;
}

After the emplace insertion, hm1 contains:
1 => a

hash_map::empty

Testet, ob ein hash_map-Element leer ist.

bool empty() const;

Rückgabewert

true wenn die hash_map leer ist; false wenn dies hash_map nicht zu ernennen ist.

Hinweise

Beispiel

// hash_map_empty.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1, hm2;

   typedef pair <int, int> Int_Pair;
   hm1.insert ( Int_Pair ( 1, 1 ) );

   if ( hm1.empty( ) )
      cout << "The hash_map hm1 is empty." << endl;
   else
      cout << "The hash_map hm1 is not empty." << endl;

   if ( hm2.empty( ) )
      cout << "The hash_map hm2 is empty." << endl;
   else
      cout << "The hash_map hm2 is not empty." << endl;
}

The hash_map hm1 is not empty.
The hash_map hm2 is empty.

hash_map::end

Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element einem hash_map-Element nachfolgt.

const_iterator end() const;

iterator end();

Rückgabewert

Ein bidirektionaler Iterator, der die Position adressiert, die das letzte Element in einem hash_map. Wenn die hash_map leer ist, gilt anschließend hash_map::end == hash_map::begin.

Hinweise

end wird verwendet, um zu testen, ob ein Iterator das Ende seines hash_map erreicht hat.

Der zurückgegebene end Wert sollte nicht abgeleitet werden.

Beispiel

// hash_map_end.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_cIter = hm1.end( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is "
        << hm1_cIter -> second << "." << endl;

   hm1_Iter = hm1.end( );
   hm1_Iter--;
   hm1.erase ( hm1_Iter );

   // The following 2 lines would err because the iterator is const
   // hm1_cIter = hm1.end ( );
   // hm1_cIter--;
   // hm1.erase ( hm1_cIter );

   hm1_cIter = hm1.end( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is now "
        << hm1_cIter -> second << "." << endl;
}

The value of last element of hm1 is 30.
The value of last element of hm1 is now 20.

hash_map::equal_range

Gibt ein Iteratorpaar jeweils bezogen auf das erste Element in einem hash_map-Objekt mit einem Schlüssel zurück, der größer als ein bestimmter Schlüssel ist, bzw. bezogen auf das erste Element im hash_map-Objekt mit einem Schlüssel, der größer oder gleich dem Schlüssel ist.

pair <const_iterator, const_iterator> equal_range (const Key& key) const;

pair <iterator, iterator> equal_range (const Key& key);

Parameter

key
Der Argumentschlüsselwert, der mit dem Sortierschlüssel eines Elements aus dem hash_map durchsuchten Element verglichen werden soll.

Rückgabewert

Ein Paar Iteratoren, sodass der erste der lower_bound Schlüssel und der zweite der upper_bound Schlüssel ist.

Um auf den ersten Iterator eines von der Memberfunktion zurückgegebenen Paares pr zuzugreifen, verwenden pr.first Sie die Untergrenze *(pr.first)des Iterators, und leiten Sie es ab. Um auf den zweiten Iterator eines von der Memberfunktion zurückgegebenen Paares pr zuzugreifen, verwenden Sie den oberen begrenzungsfähigen Iterator, und pr.second leiten Sie es ab *(pr.second).

Hinweise

Beispiel

// hash_map_equal_range.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_map <int, int> IntMap;
   IntMap hm1;
   hash_map <int, int> :: const_iterator hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   pair <IntMap::const_iterator, IntMap::const_iterator> p1, p2;
   p1 = hm1.equal_range( 2 );

   cout << "The lower bound of the element with "
        << "a key of 2 in the hash_map hm1 is: "
        << p1.first -> second << "." << endl;

   cout << "The upper bound of the element with "
        << "a key of 2 in the hash_map hm1 is: "
        << p1.second -> second << "." << endl;

   // Compare the upper_bound called directly
   hm1_RcIter = hm1.upper_bound( 2 );

   cout << "A direct call of upper_bound( 2 ) gives "
        << hm1_RcIter -> second << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 2 )." << endl;

   p2 = hm1.equal_range( 4 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == hm1.end( ) ) && ( p2.second == hm1.end( ) ) )
      cout << "The hash_map hm1 doesn't have an element "
             << "with a key less than 40." << endl;
   else
      cout << "The element of hash_map hm1 with a key >= 40 is: "
           << p1.first -> first << "." << endl;
}

The lower bound of the element with a key of 2 in the hash_map hm1 is: 20.
The upper bound of the element with a key of 2 in the hash_map hm1 is: 30.
A direct call of upper_bound( 2 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 2 ).
The hash_map hm1 doesn't have an element with a key less than 40.

hash_map::erase

Es wird ein Element oder ein Bereich von Elementen in einem hash_map von angegebenen Speicherorten entfernt, oder es werden die einem angegebenen Schlüssel entsprechenden Elemente entfernt.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Parameter

_Where
Die Position des Elements, das aus dem hash_mapElement entfernt werden soll.

first
Position des ersten Elements, das aus dem hash_map.

last
Position direkt über dem letzten Element entfernt aus dem hash_map.

key
Der Schlüsselwert der Elemente, die aus dem hash_mapElement entfernt werden sollen.

Rückgabewert

Bei den ersten beiden Memberfunktionen wird ein bidirektionaler Iterator, der das erste Element bestimmt, das über alle entfernten Elemente hinausgeht, oder einen Zeiger auf das Ende des hash_map Elements, wenn kein solches Element vorhanden ist.

Gibt für die dritte Memberfunktion die Anzahl der Elemente zurück, die aus dem hash_mapElement entfernt wurden.

Hinweise

Von der Memberfunktionen wird nie eine Ausnahme ausgelöst.

Beispiel

Im folgenden Beispiel wird die Verwendung der hash_map::erase Memberfunktion veranschaulicht.

// hash_map_erase.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1, hm2, hm3;
    hash_map<int, int> :: iterator pIter, Iter1, Iter2;
    int i;
    hash_map<int, int>::size_type n;
    typedef pair<int, int> Int_Pair;

    for (i = 1; i < 5; i++)
    {
        hm1.insert(Int_Pair (i, i));
        hm2.insert(Int_Pair (i, i*i));
        hm3.insert(Int_Pair (i, i-1));
    }

    // The 1st member function removes an element at a given position
    Iter1 = ++hm1.begin();
    hm1.erase(Iter1);

    cout << "After the 2nd element is deleted, the hash_map hm1 is:";
    for (pIter = hm1.begin(); pIter != hm1.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 2nd member function removes elements
    // in the range [ first,  last)
    Iter1 = ++hm2.begin();
    Iter2 = --hm2.end();
    hm2.erase(Iter1, Iter2);

    cout << "After the middle two elements are deleted, "
         << "the hash_map hm2 is:";
    for (pIter = hm2.begin(); pIter != hm2.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 3rd member function removes elements with a given  key
    n = hm3.erase(2);

    cout << "After the element with a key of 2 is deleted,\n"
         << "the hash_map hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 3rd member function returns the number of elements removed
    cout << "The number of elements removed from hm3 is: "
         << n << "." << endl;

    // The dereferenced iterator can also be used to specify a key
    Iter1 = ++hm3.begin();
    hm3.erase(Iter1);

    cout << "After another element with a key equal to that"
         << endl;
    cout  << "of the 2nd element is deleted, "
          << "the hash_map hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;
}

After the 2nd element is deleted, the hash_map hm1 is: 1 3 4.
After the middle two elements are deleted, the hash_map hm2 is: 1 16.
After the element with a key of 2 is deleted,
the hash_map hm3 is: 0 2 3.
The number of elements removed from hm3 is: 1.
After another element with a key equal to that
of the 2nd element is deleted, the hash_map hm3 is: 0 3.

hash_map::find

Gibt einen Iterator zurück, der die Position eines Elements in einem hash_map-Element adressiert, das einen Schlüssel aufweist, der einen angegebenen Schlüssel entspricht.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parameter

key
Der Schlüsselwert, der durch den Sortierschlüssel eines Elements abgeglichen werden soll, aus dem hash_map durchsucht wird.

Rückgabewert

Ein Iterator, der die Position eines Elements mit einem angegebenen Schlüssel adressiert, oder die Position, an der das letzte Element im letzten Element erfolgreich hash_map war, wenn keine Übereinstimmung für den Schlüssel gefunden wird.

Hinweise

find gibt einen Iterator zurück, der hash_map ein Element im Sortierschlüssel adressiert, dessen Sortierschlüssel dem Argumentschlüssel unter einem binären Prädikat entspricht, das eine Sortierung basierend auf einer Vergleichbarkeitsbeziehung auslöst.

Wenn der Rückgabewert find eines const_iteratorObjekts zugewiesen ist, kann das hash_map Objekt nicht geändert werden. Wenn der Rückgabewert find eines iteratorObjekts zugewiesen ist, kann das hash_map Objekt geändert werden.

Beispiel

// hash_map_find.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.find( 2 );
   cout << "The element of hash_map hm1 with a key of 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   hm1_RcIter = hm1.find( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_map can be found
   // using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.end( );
   hm1_AcIter--;
   hm1_RcIter = hm1.find( hm1_AcIter -> first );
   cout << "The element of hm1 with a key matching "
        << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;
}

The element of hash_map hm1 with a key of 2 is: 20.
The hash_map hm1 doesn't have an element with a key of 4.
The element of hm1 with a key matching that of the last element is: 30.

hash_map::get_allocator

Gibt eine Kopie des allocator -Objekts zurück, das zum Erstellen des hash_mapObjekts verwendet wird.

Allocator get_allocator() const;

Rückgabewert

Der von der hash_mapZuweisung verwendete Allokator .

Hinweise

Allocators für die hash_map Klasse geben an, wie die Klasse Speicher verwaltet. Für die meisten Programmieranforderungen reichen die standardmäßigen allocator-Objekte mit Container-Klassen der C++-Standardbibliothek aus. Schreiben und Verwenden Ihrer eigener Zuweisungsklasse ist ein C++ -Thema für Fortgeschrittene.

Beispiel

// hash_map_get_allocator.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int>::allocator_type hm1_Alloc;
   hash_map <int, int>::allocator_type hm2_Alloc;
   hash_map <int, double>::allocator_type hm3_Alloc;
   hash_map <int, int>::allocator_type hm4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   hash_map <int, int> hm1;
   hash_map <int, int> hm2;
   hash_map <int, double> hm3;

   hm1_Alloc = hm1.get_allocator( );
   hm2_Alloc = hm2.get_allocator( );
   hm3_Alloc = hm3.get_allocator( );

   cout << "The number of integers that can be allocated"
        << endl << "before free memory is exhausted: "
        << hm2.max_size( ) << "." << endl;

   cout << "The number of doubles that can be allocated"
        << endl << "before free memory is exhausted: "
        << hm3.max_size( ) <<  "." << endl;

   // The following line creates a hash_map hm4
   // with the allocator of hash_map hm1.
   hash_map <int, int> hm4( less<int>( ), hm1_Alloc );

   hm4_Alloc = hm4.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated with the other
   if( hm1_Alloc == hm4_Alloc )
   {
      cout << "The allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "The allocators are not interchangeable."
           << endl;
   }
}

hash_map::hash_map

Erstellt ein leeres hash_map Objekt oder eine Kopie eines teils oder aller anderen hash_mapElemente.

hash_map();

explicit hash_map(
    const Traits& Comp);

hash_map(
    const Traits& Comp,
    const Allocator& Al);

hash_map(
    const hash_map& Right);

hash_map(
    hash_map&& Right);

hash_map(
    initializer_list<Type> IList);hash_map(initializer_list<Type> IList,
    const key_compare& Comp);

hash_map(
    initializer_list<Type> IList,
    const key_compare& Comp,
    const allocator_type& Al);

template <class InputIterator>
hash_map(
    InputIterator First,
    InputIterator Last);

template <class InputIterator>
hash_map(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp);

template <class InputIterator>
hash_map(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp,
    const Allocator& Al

Parameter

Al
Die für dieses hash_map-Objekt zu verwendende Speicherzuweisungsklasse, dessen Standard Allocator ist.

Comp
Die Vergleichsfunktion des Typs Const Traits , die verwendet wird, um die Elemente in der hash_mapStandardeinstellung hash_comparezu ordnen.

Right
Die hash_map erstellte Karte soll eine Kopie sein.

First
Die Position des ersten Elements in dem zu kopierenden Elementbereich.

Last
Die Position des ersten Elements nach dem zu kopierenden Elementbereich.

IList
Der initializer_list

Hinweise

Alle Konstruktoren speichern einen Typ von Allocator-Objekt, der speicherverwaltung für den hash_map und kann später durch Aufrufen get_allocatorzurückgegeben werden. Der Zuweisungsparameter wird häufig aus den Klassendeklarationen und den Vorverarbeitungsmakros weggelassen, die zum Ersetzen alternativer Zuweisungen verwendet werden.

Alle Konstruktoren initialisieren ihre hash_map.

Alle Konstruktoren speichern ein Funktionsobjekt vom Typ Traits , das verwendet wird, um eine Reihenfolge zwischen den Schlüsseln der hash_map und die später durch Aufrufen key_compzurückgegeben werden können.

Die ersten drei Konstruktoren geben außerdem einen leeren Anfangstyp hash_mapan, und der zweite gibt den Typ der Vergleichsfunktion (Comp) an, der verwendet werden soll, um die Reihenfolge der Elemente festzulegen, und der dritte explizit den zu verwendenden Allocatortyp (Al) an. Mit dem Schlüsselwort explicit werden bestimmte Arten automatischer Typumwandlung unterdrückt.

Der vierte Konstruktor gibt eine Kopie der hash_map Right.

Die nächsten drei Konstruktoren kopieren den Bereich eines hash_map Bereichs [First, Last) mit zunehmender Explizitkeit bei der Angabe des Typs der Vergleichsfunktion der Klasse Traits und des Allokators.

Der letzte Konstruktor verschiebt die hash_map Right.

hash_map::insert

Fügt ein Element oder einen Elementbereich in ein hash_map-Element ein.

pair <iterator, bool> insert(
    const value_type& val);

iterator insert(
    const_iterator _Where,
    const value_type& val);

template <class InputIterator>
void insert(
    InputIterator first,
    InputIterator last);

template <class ValTy>
pair <iterator, bool>
insert(
    ValTy&& val);

template <class ValTy>
iterator insert(
    const_iterator _Where,
    ValTy&& val);

Parameter

val
Der Wert eines Elements, das in das hash_map Element eingefügt werden soll, es sei denn, das hash_map Element enthält dieses Element (oder im Allgemeinen ein Element, dessen Schlüssel äquivalent sortiert ist).

_Where
Ein Hinweis bezüglich des Platzes, an dem mit der Suche nach dem richtigen Einfügepunkt begonnen wird.

first
Die Position des ersten Elements, das aus hash_map kopiert werden soll.

last
Die Position direkt über den letzten aus hash_map zu kopierenden Elements.

Rückgabewert

Die erste insert Memberfunktion gibt ein Paar zurück, dessen bool Komponente zurückgibt true , ob eine Einfügung vorgenommen wurde und false ob das hash_map element bereits ein Element enthielt, dessen Schlüssel einen entsprechenden Wert in der Sortierung aufweist und dessen Iteratorkomponente die Adresse zurückgibt, an der ein neues Element eingefügt wurde oder wo sich das Element bereits befindet.

Um auf die Iteratorkomponente eines pr-Paares zuzugreifen, das von dieser Memberfunktion zurückgegeben wird, verwenden Sie pr.first und (pr.first), um es zu dereferenzieren. Um auf die bool-Komponente eines pr-Paares zuzugreifen, das von dieser Memberfunktion zurückgegeben wird, verwenden Sie pr.second und \(pr.second), um es zu dereferenzieren.

Die zweite insert Memberfunktion, die Hint-Version, gibt einen Iterator zurück, der auf die Position zeigt, an der das neue Element in die hash_map.

Die letzten beiden insert Memberfunktionen verhalten sich genauso wie die ersten beiden, mit der Ausnahme, dass sie den eingefügten Wert verschieben.

Hinweise

Das value_type Element ist ein Paar, sodass der Wert eines Elements ein geordnetes Paar mit der ersten Komponente ist, die dem Schlüsselwert und der zweiten Komponente entspricht dem Datenwert des Elements.

Einfügung kann in amortisierter konstanter Zeit anstelle von logarithmischer Zeit für die Hinweisversion von "insert" erfolgen, wenn die Einfügemarke _Where direkt folgt.

Die dritte Memberfunktion fügt die Abfolge von Elementwerten in ein hash_map entsprechendes Element ein, das von einem Iterator im Bereich *[First, Last)* eines angegebenen Satzes adressiert wird.

Beispiel

// hash_map_insert.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int>::iterator hm1_pIter, hm2_pIter;

    hash_map<int, int> hm1, hm2;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 10));
    hm1.insert(Int_Pair(2, 20));
    hm1.insert(Int_Pair(3, 30));
    hm1.insert(Int_Pair(4, 40));

    cout << "The original elements (Key => Value) of hm1 are:";
    for (hm1_pIter = hm1.begin(); hm1_pIter != hm1.end(); hm1_pIter++)
        cout << endl << " " << hm1_pIter -> first << " => "
             << hm1_pIter->second;
    cout << endl;

    pair< hash_map<int,int>::iterator, bool > pr;
    pr = hm1.insert(Int_Pair(1, 10));

    if (pr.second == true)
    {
        cout << "The element 10 was inserted in hm1 successfully."
            << endl;
    }
    else
    {
        cout << "The element 10 already exists in hm1\n"
            << "with a key value of "
            << "((pr.first) -> first) = " << (pr.first)->first
            << "." << endl;
    }

    // The hint version of insert
    hm1.insert(--hm1.end(), Int_Pair(5, 50));

    cout << "After the insertions, the elements of hm1 are:";
    for (hm1_pIter = hm1.begin(); hm1_pIter != hm1.end(); hm1_pIter++)
        cout << endl << hm1_pIter -> first << " => "
             << hm1_pIter->second;
    cout << endl;

    hm2.insert(Int_Pair(10, 100));

    // The templatized version inserting a range
    hm2.insert( ++hm1.begin(), --hm1.end() );

    cout << "After the insertions, the elements of hm2 are:";
    for (hm2_pIter = hm2.begin(); hm2_pIter != hm2.end(); hm2_pIter++)
        cout << endl << hm2_pIter -> first << " => "
             << hm2_pIter->second;
    cout << endl;

    // The templatized versions move constructing elements
    hash_map<int, string> hm3, hm4;
    pair<int, string> is1(1, "a"), is2(2, "b");

    hm3.insert(move(is1));
    cout << "After the move insertion, hm3 contains:" << endl
      << hm3.begin()->first
      << " => " << hm3.begin()->second
      << endl;

    hm4.insert(hm4.begin(), move(is2));
    cout << "After the move insertion, hm4 contains:" << endl
      << hm4.begin()->first
      << " => " << hm4.begin()->second
      << endl;
}

The original elements (Key => Value) of hm1 are:
1 => 10
2 => 20
3 => 30
4 => 40
The element 10 already exists in hm1
with a key value of ((pr.first) -> first) = 1.
After the insertions, the elements of hm1 are:
1 => 10
2 => 20
3 => 30
4 => 40
5 => 50
After the insertions, the elements of hm2 are:
2 => 20
10 => 100
3 => 30
4 => 40
After the move insertion, hm3 contains:
1 => a
After the move insertion, hm4 contains:
2 => b

hash_map::iterator

Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem jedes Element in einer hash_map gelesen oder geändert werden kann.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::iterator iterator;

Hinweise

Die iterator durch Punkte definierten hash_map Elemente, bei denen es sich um Objekte vom value_typeTyp pair<const Key, Type>handelt , deren erstes Element der Schlüssel für das Element ist und dessen zweites Element das zugeordnete Datum ist, das vom Element gehalten wird.

Verwenden Sie den -> Operator, um einen Iterator abzuleiten, der auf Iter ein Element in einer Multimap zeigt.

Um auf den Wert des Schlüssels für das Element zuzugreifen, verwenden Sie Iter->firstdie Entsprechende .(*Iter).first Um auf den Wert des zugeordneten Datums für das Element zuzugreifen, verwenden Sie Iter->seconddies , was entspricht (*Iter).second.

Ein Typ iterator kann verwendet werden, um den Wert eines Elements zu ändern.

Beispiel

Ein Beispiel für begin das Deklarieren und Verwenden der iterator.

hash_map::key_comp

Ruft eine Kopie des Vergleichsobjekts ab, das zum Sortieren der Schlüssel in hash_map verwendet wird.

key_compare key_comp() const;

Rückgabewert

Gibt das Funktionsobjekt zurück, das zum hash_map Sortieren seiner Elemente verwendet wird.

Hinweise

Das gespeicherte Objekt definiert die Memberfunktion

bool operator( const Key& left, const Key&right );

die zurückgibt true , ob left sie vorangestellt ist und nicht in der Sortierreihenfolge gleich ist right .

Beispiel

// hash_map_key_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_map <int, int, hash_compare<int, less<int> > > hm1;
   hash_map <int, int, hash_compare<int, less<int> > >::key_compare
      kc1 = hm1.key_comp( ) ;

   // Operator stored in kc1 tests order & returns bool value
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true,"
           << "\n where kc1 is the function object of hm1"
           << " of type key_compare." << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false"
           << "\n where kc1 is the function object of hm1"
           << " of type key_compare." << endl;
   }

   hash_map <int, int, hash_compare<int, greater<int> > > hm2;
   hash_map <int, int, hash_compare<int, greater<int> > >
      ::key_compare kc2 = hm2.key_comp( );

   // Operator stored in kc2 tests order & returns bool value
   bool result2 = kc2( 2, 3 ) ;
   if( result2 == true )
   {
      cout << "kc2( 2,3 ) returns value of true,"
           << "\n where kc2 is the function object of hm2"
           << " of type key_compare." << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false,"
           << "\n where kc2 is the function object of hm2"
           << " of type key_compare." << endl;
   }
}

hash_map::key_compare

Eine Typ, der ein Funktionsobjekt bereitstellt, das zwei Sortierschlüssel vergleichen kann, um die relative Position von zwei Elementen in der hash_map zu bestimmen.

typedef Traits key_compare;

Hinweise

key_compare ist ein Synonym für den Vorlagenparameter Traits.

Weitere Informationen Traits finden Sie im hash_map Thema "Klasse ".

Beispiel

Ein Beispiel für key_comp das Deklarieren und Verwenden key_comparefinden Sie im Beispiel.

hash_map::key_type

Ein Typ beschreibt das Sortierschlüsselobjekt, das jedes Element von hash_map bildet.

typedef Key key_type;

Hinweise

key_type ist ein Synonym für den Vorlagenparameter Key.

Weitere Informationen Keyfinden Sie im Abschnitt "Hinweise" des hash_map Themas "Klasse ".

Beispiel

Ein Beispiel für value_type das Deklarieren und Verwenden key_typefinden Sie im Beispiel.

hash_map::lower_bound

Gibt einen Iterator zum ersten Element in einem hash_map-Element mit einem Schlüsselwert zurück, der gleich oder größer ist, als ein angegebener Schlüssel.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parameter

key
Der Argumentschlüsselwert, der mit dem Sortierschlüssel eines Elements aus dem hash_map durchsuchten Element verglichen werden soll.

Rückgabewert

Eine iterator oder const_iterator die die Position eines Elements in einem hash_map Element angibt, das mit einem Schlüssel gleich oder größer als dem Argumentschlüssel ist, oder die die Position angibt, an der das letzte Element erfolgreich war hash_map , wenn keine Übereinstimmung für den Schlüssel gefunden wird.

Wenn der Rückgabewert lower_bound eines const_iteratorObjekts zugewiesen ist, kann das hash_map Objekt nicht geändert werden. Wenn der Rückgabewert lower_bound eines iteratorObjekts zugewiesen ist, kann das hash_map Objekt geändert werden.

Hinweise

Beispiel

// hash_map_lower_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.lower_bound( 2 );
   cout << "The first element of hash_map hm1 with a key of 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   hm1_RcIter = hm1. lower_bound ( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // An element at a specific location in the hash_map can be
   // found using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.end( );
   hm1_AcIter--;
   hm1_RcIter = hm1. lower_bound ( hm1_AcIter -> first );
   cout << "The element of hm1 with a key matching "
        << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;
}

The first element of hash_map hm1 with a key of 2 is: 20.
The hash_map hm1 doesn't have an element with a key of 4.
The element of hm1 with a key matching that of the last element is: 30.

hash_map::mapped_type

Ein Typ, der den in einer hash_map gespeicherten Datentyp darstellt.

typedef Type mapped_type;

Hinweise

Der Typ mapped_type stellt ein Synonym für den Vorlagenparameter Type dar.

Weitere Informationen Type finden Sie im hash_map Thema "Klasse ".

Beispiel

Ein Beispiel für value_type das Deklarieren und Verwenden key_typefinden Sie im Beispiel.

hash_map::max_size

Gibt die Maximallänge der hash_map zurück.

size_type max_size() const;

Rückgabewert

Die maximal mögliche Länge der hash_map.

Hinweise

Beispiel

// hash_map_max_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: size_type i;

   i = hm1.max_size( );
   cout << "The maximum possible length "
        << "of the hash_map is " << i << "."
        << endl << "(Magnitude is machine specific.)";
}

hash_map::operator[]

Fügt ein Element in ein hash_map-Element mit einem angegebenen Schlüsselwert ein.

Type& operator[](const Key& key);

Type& operator[](Key&& key);

Parameter

key
Der Schlüsselwert des einzufügenden Elements.

Rückgabewert

Ein Verweis auf den Datenwert des eingefügten Elements.

Hinweise

Wenn der Argumentschlüsselwert nicht gefunden wird, wird er zusammen mit dem Standardwert des Datentyps eingefügt.

operator[] kann auch zum Einfügen von Elementen in einem hash_map m verwendet werden, unter Verwendung von

m[ key] = DataValue;

dort wo der DataValue der Wert des mapped_type des Elements mit einem Schlüsselwert von key ist.

Beim Einfügen von operator[] Elementen gibt der zurückgegebene Verweis nicht an, ob eine Einfügung ein bereits vorhandenes Element ändert oder ein neues Element erstellt. Die Memberfunktionen find und insert können verwendet werden, um zu bestimmen, ob ein Element mit einer angegebenen Taste bereits vor der Einfügung vorhanden ist.

Beispiel

// hash_map_op_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;
   hash_map <int, int> :: iterator pIter;

   // Insert a data value of 10 with a key of 1
   // into a hash_map using the operator[] member function
   hm1[ 1 ] = 10;

   // Compare other ways to insert objects into a hash_map
   hm1.insert ( hash_map <int, int> :: value_type ( 2, 20 ) );
   hm1.insert ( cInt2Int ( 3, 30 ) );

   cout  << "The keys of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;

   // If the key already exists, operator[]
   // changes the value of the datum in the element
   hm1[ 2 ] = 40;

   // operator[] will also insert the value of the data
   // type's default constructor if the value is unspecified
   hm1[5];

   cout  << "The keys of the mapped elements are now:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are now:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;

   // operator[] will also insert by moving a key
   hash_map <string, int> hm2;
   string str("a");
   hm2[move(str)] = 1;
   cout << "The moved key is " << hm2.begin()->first
      << ", with value " << hm2.begin()->second << endl;
}

hash_map::operator=

Ersetzt die Elemente der hash_map mit einer Kopie einer anderen hash_map.

hash_map& operator=(const hash_map& right);

hash_map& operator=(hash_map&& right);

Parameter

right
Die right Klasse , die in die hash_mapDatei kopiert wird.

Hinweise

Nachdem ein vorhandenes Element in einem hash_map gelöscht wurde, kopiert oder verschiebt operator= den Inhalt von right in den hash_map.

Beispiel

// hash_map_operator_as.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map<int, int> v1, v2, v3;
   hash_map<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;
}

hash_map::pointer

Ein Typ, der einen Zeiger auf ein Element in einer hash_map bereitstellt.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::pointer pointer;

Hinweise

Ein Typ pointer kann verwendet werden, um den Wert eines Elements zu ändern.

In den meisten Fällen sollte ein iterator Objekt verwendet werden, um auf die Elemente in einem hash_map Objekt zuzugreifen.

hash_map::rbegin

Gibt einen Iterator zurück, der das erste Element in einem umgekehrten hash_map-Element adressiert.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Rückgabewert

Ein umgekehrter bidirektionaler Iterator, der das erste Element in einer umgekehrten hash_map Oder adressiert, was das letzte Element in der unreversierten hash_map.

Hinweise

rbegin wird mit einem umgekehrten hash_map verwendet, genau wie begin bei einem hash_map.

Wenn der Rückgabewert rbegin eines const_reverse_iteratorObjekts zugewiesen ist, kann das hash_map Objekt nicht geändert werden. Wenn der Rückgabewert rbegin eines reverse_iteratorObjekts zugewiesen ist, kann das hash_map Objekt geändert werden.

Mit rbegin kann ein hash_map rückwärts durchlaufen werden.

Beispiel

// hash_map_rbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: reverse_iterator hm1_rIter;
   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_rIter = hm1.rbegin( );
   cout << "The first element of the reversed hash_map hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_map in a forward order
   cout << "The hash_map is: ";
   for ( hm1_Iter = hm1.begin( ) ; hm1_Iter != hm1.end( ); hm1_Iter++)
      cout << hm1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a hash_map in a reverse order
   cout << "The reversed hash_map is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_map element can be erased by dereferencing to its key
   hm1_rIter = hm1.rbegin( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed hash_map is "
        << hm1_rIter -> first << "." << endl;
}

The first element of the reversed hash_map hm1 is 3.
The hash_map is: 1 2 3 .
The reversed hash_map is: 3 2 1 .
After the erasure, the first element in the reversed hash_map is 2.

hash_map::reference

Ein Typ, der einen Verweis auf ein in einer hash_map gespeichertes Element bereitstellt.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::reference reference;

Hinweise

Beispiel

// hash_map_reference.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( hm1.begin( ) -> first );

   // The following line would cause an error as the
   // non-const_reference cannot be used to access the key
   // int &Ref1 = ( hm1.begin( ) -> first );

   cout << "The key of first element in the hash_map is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( hm1.begin( ) -> second );

   cout << "The data value of first element in the hash_map is "
        << Ref2 << "." << endl;

   // The non-const_reference can be used to modify the
   // data value of the first element
   Ref2 = Ref2 + 5;
   cout << "The modified data value of first element is "
        << Ref2 << "." << endl;
}

The key of first element in the hash_map is 1.
The data value of first element in the hash_map is 10.
The modified data value of first element is 15.

hash_map::rend

Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines umgekehrten hash_map-Elements nachfolgt.

const_reverse_iterator rend() const;

reverse_iterator rend();

Rückgabewert

Ein umgekehrter bidirektionaler Iterator, der die Position adressiert, die das letzte Element in einem umgekehrten hash_map Element erfolgreich war (die Position, die dem ersten Element in der unreversierten hash_mapSeite vorausging).

Hinweise

rend wird mit einem umgekehrten hash_map verwendet, genau wie end bei einem hash_map.

Wenn der Rückgabewert rend eines const_reverse_iteratorObjekts zugewiesen ist, kann das hash_map Objekt nicht geändert werden. Wenn der Rückgabewert rend eines reverse_iteratorObjekts zugewiesen ist, kann das hash_map Objekt geändert werden.

rend kann verwendet werden, um zu testen, ob das Ende der hash_map von einem umgekehrten Iterator erreicht wurde.

Der zurückgegebene rend Wert sollte nicht abgeleitet werden.

Beispiel

// hash_map_rend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: reverse_iterator hm1_rIter;
   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_rIter = hm1.rend( );
   hm1_rIter--;
   cout << "The last element of the reversed hash_map hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_map in a forward order
   cout << "The hash_map is: ";
   for ( hm1_Iter = hm1.begin( ) ; hm1_Iter != hm1.end( );
   hm1_Iter++)
      cout << hm1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a hash_map in a reverse order
   cout << "The reversed hash_map is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( );
      hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_map element can be erased by dereferencing to its key
   hm1_rIter = --hm1.rend( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rend( );
   hm1_rIter--;
   cout << "After the erasure, the last element "
        << "in the reversed hash_map is "
        << hm1_rIter -> first << "." << endl;
}

The last element of the reversed hash_map hm1 is 1.
The hash_map is: 1 2 3 .
The reversed hash_map is: 3 2 1 .
After the erasure, the last element in the reversed hash_map is 2.

hash_map::reverse_iterator

Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem ein Element in einem umgekehrten hash_map-Element gelesen oder geändert werden kann.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::reverse_iterator reverse_iterator;

Hinweise

Ein Typ reverse_iterator kann den Wert eines Elements nicht ändern und wird zum Durchlaufen des hash_map umgekehrten Elements verwendet.

Die reverse_iterator durch Punkte definierten hash_map Elemente, die Objekte von value_type sind, d. h. vom Typ pair<const Key, Type>, deren erstes Element der Schlüssel für das Element ist und dessen zweites Element das zugeordnete Datum ist, das vom Element gehalten wird.

Verwenden Sie den -> Operator, um ein reverse_iterator rIter Element in einem hash_mapElement abzuleiten.

Um auf den Wert des Schlüssels für das Element zuzugreifen, verwenden Sie rIter->firstdie Entsprechende .(*rIter).first Um auf den Wert des zugeordneten Datums für das Element zuzugreifen, verwenden Sie rIter->seconddies , was entspricht (*rIter).first.

Beispiel

Ein Beispiel für rbegin das Deklarieren und Verwenden reverse_iteratorfinden Sie im Beispiel.

hash_map::size

Gibt die Anzahl von Elementen in der hash_map zurück.

size_type size() const;

Rückgabewert

Die aktuelle Länge des hash_map.

Hinweise

Beispiel

Im folgenden Beispiel wird die Verwendung der hash_map::size Memberfunktion veranschaulicht.

// hash_map_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1, hm2;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 1));
    i = hm1.size();
    cout << "The hash_map length is " << i << "." << endl;

    hm1.insert(Int_Pair(2, 4));
    i = hm1.size();
    cout << "The hash_map length is now " << i << "." << endl;
}

The hash_map length is 1.
The hash_map length is now 2.

hash_map::size_type

Eine Ganzzahltyp ohne Vorzeichen, der die Anzahl von Elementen in hash_map darstellen kann.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::size_type size_type;

Hinweise

Beispiel

Ein Beispiel für size das Deklarieren und Verwenden finden Sie unter size_type

hash_map::swap

Tauscht die Elemente zweier hash_mapn.

void swap(hash_map& right);

Parameter

right
Das Argument hash_map , das die Elemente bereitstellt, die mit dem Ziel hash_mapausgetauscht werden sollen.

Hinweise

Die Memberfunktion weist keine Verweise, Zeiger oder Iteratoren auf, die Elemente in den beiden hash_mapElementen kennzeichnen, deren Elemente ausgetauscht werden.

Beispiel

// hash_map_swap.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1, hm2, hm3;
   hash_map <int, int>::iterator hm1_Iter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );
   hm2.insert ( Int_Pair ( 10, 100 ) );
   hm2.insert ( Int_Pair ( 20, 200 ) );
   hm3.insert ( Int_Pair ( 30, 300 ) );

   cout << "The original hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;

   // This is the member function version of swap
   // hm2 is said to be the argument hash_map;
   // hm1 is said to be the target hash_map
   hm1.swap( hm2 );

   cout << "After swapping with hm2, hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hm1, hm3 );

   cout << "After swapping with hm3, hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;
}

The original hash_map hm1 is: 10 20 30.
After swapping with hm2, hash_map hm1 is: 100 200.
After swapping with hm3, hash_map hm1 is: 300.

hash_map::upper_bound

Gibt einen Iterator an das erste Element in einem hash_map Element zurück, bei dem ein Schlüssel einen Wert aufweist, der größer als der eines angegebenen Schlüssels ist.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parameter

key
Der Argumentschlüsselwert, der mit dem Sortierschlüsselwert eines Elements aus dem hash_map durchsuchten Element verglichen werden soll.

Rückgabewert

Eine iterator oder const_iterator die die Position eines Elements in einem hash_map Element angibt, das einen Schlüssel enthält, der größer als der Argumentschlüssel ist, oder die die Position adressiert, an der das letzte Element im letzten Element gefunden hash_map wird, wenn keine Übereinstimmung für den Schlüssel gefunden wird.

Wenn dem Rückgabewert ein const_iteratorWert zugewiesen ist, kann das hash_map Objekt nicht geändert werden. Wenn dem Rückgabewert ein iteratorWert zugewiesen ist, kann das hash_map Objekt geändert werden.

Hinweise

Beispiel

// hash_map_upper_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.upper_bound( 2 );
   cout << "The first element of hash_map hm1 with a key "
        << "greater than 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end is returned
   hm1_RcIter = hm1. upper_bound ( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key greater than 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key > 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_map can be found
   // using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.begin( );
   hm1_RcIter = hm1. upper_bound ( hm1_AcIter -> first );
   cout << "The 1st element of hm1 with a key greater than that\n"
        << "of the initial element of hm1 is: "
        << hm1_RcIter -> second << "." << endl;
}

The first element of hash_map hm1 with a key greater than 2 is: 30.
The hash_map hm1 doesn't have an element with a key greater than 4.
The 1st element of hm1 with a key greater than that
of the initial element of hm1 is: 20.

hash_map::value_comp

Gibt ein Funktionsobjekt zurück, das die Reihenfolge von Elementen in einem hash_map Element bestimmt, indem die Schlüsselwerte verglichen werden.

value_compare value_comp() const;

Rückgabewert

Gibt das Vergleichsfunktionsobjekt zurück, das zum hash_map Sortieren seiner Elemente verwendet wird.

Hinweise

Bei einem hash_map m, wenn zwei Elemente e1 (k1, d1) und e2 (k2, d2) Objekte vom Typ value_typesind , wobei k1 und k2 ihre Schlüssel vom Typ key_type sind und deren d2 d1 Daten vom Typ mapped_typesind , dann entspricht es m.value_comp()(e1, e2) m.key_comp()(k1, k2). Ein gespeichertes Objekt definiert die Memberfunktion

bool operator(value_type& left, value_type& right);

gibt zurück true , wenn der Schlüsselwert vorangestellter left Wert ist und nicht dem Schlüsselwert right in der Sortierreihenfolge entspricht.

Beispiel

// hash_map_value_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_map <int, int, hash_compare<int, less<int> > > hm1;
   hash_map <int, int, hash_compare<int, less<int> > >
   ::value_compare vc1 = hm1.value_comp( );
   pair< hash_map<int,int>::iterator, bool > pr1, pr2;

   pr1= hm1.insert ( hash_map <int, int> :: value_type ( 1, 10 ) );
   pr2= hm1.insert ( hash_map <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *pr1.first, *pr2.first ) == true )
   {
      cout << "The element ( 1,10 ) precedes the element ( 2,5 )."
           << endl;
   }
   else
   {
      cout << "The element ( 1,10 ) does not precede the element ( 2,5 )."
           << endl;
   }

   if( vc1 ( *pr2.first, *pr1.first ) == true )
   {
      cout << "The element ( 2,5 ) precedes the element ( 1,10 )."
           << endl;
   }
   else
   {
      cout << "The element ( 2,5 ) does not precede the element ( 1,10 )."
           << endl;
   }
}

hash_map::value_type

Ein Typ, der den Typ des objekts darstellt, das in einer hash_map.

typedef pair<const Key, Type> value_type;

Hinweise

value_type wird deklariert pair<const key_type, mapped_type> und nicht pair<key_type, mapped_type> , weil die Schlüssel eines assoziativen Containers möglicherweise nicht mithilfe eines nicht zusammenhängenden Iterators oder Verweises geändert werden.

Beispiel

// hash_map_value_type.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;
   hash_map <int, int> :: key_type key1;
   hash_map <int, int> :: mapped_type mapped1;
   hash_map <int, int> :: value_type value1;
   hash_map <int, int> :: iterator pIter;

   // value_type can be used to pass the correct type
   // explicitly to avoid implicit type conversion
   hm1.insert ( hash_map <int, int> :: value_type ( 1, 10 ) );

   // Compare other ways to insert objects into a hash_map
   hm1.insert ( cInt2Int ( 2, 20 ) );
   hm1[ 3 ] = 30;

   // Initializing key1 and mapped1
   key1 = ( hm1.begin( ) -> first );
   mapped1 = ( hm1.begin( ) -> second );

   cout << "The key of first element in the hash_map is "
        << key1 << "." << endl;

   cout << "The data value of first element in the hash_map is "
        << mapped1 << "." << endl;

   // The following line would cause an error because
   // the value_type is not assignable
   // value1 = cInt2Int ( 4, 40 );

   cout  << "The keys of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;
}

The key of first element in the hash_map is 1.
The data value of first element in the hash_map is 10.
The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 30.

Siehe auch

Threadsicherheit in der C++-Standardbibliothek
C++-Standardbibliotheksreferenz