Classe hash_map

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Archivia e recupera i dati rapidamente da una raccolta in cui ogni elemento è una coppia che ha una chiave di ordinamento con valore univoco e un valore di dati associato.

Sintassi

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

Parametri

Key
Tipo di dati chiave da archiviare in hash_map.

Type
Tipo di dati degli elementi da archiviare in hash_map.

Traits
Tipo che include due oggetti funzione, uno della classe confronta in grado di confrontare due valori di elemento come chiavi di ordinamento per determinare l'ordine relativo e una funzione hash che è un predicato unario che esegue il mapping dei valori chiave degli elementi a interi senza segno di tipo size_t. Questo argomento è facoltativo ed hash_compare<Key, less<Key>> è il valore predefinito.

Allocator
Tipo che rappresenta l'oggetto allocatore archiviato che incapsula i dettagli sull'allocazione hash_mape la deallocazione della memoria. Questo argomento è facoltativo e il valore predefinito è allocator<pair <const Key, Type>>.

Osservazioni:

è hash_map :

• Un contenitore associativo, che è un contenitore di dimensioni variabili che supporta il recupero efficiente dei valori degli elementi in base al valore di una chiave associata.

• Reversibile, in quanto fornisce un iteratore bidirezionale per accedere ai relativi elementi.

• Con hash, poiché i rispettivi elementi sono raggruppati in bucket in base al valore di una funzione hash applicata ai valori di chiave degli elementi.

• Univoco nel senso che ogni elemento deve disporre di una chiave univoca.

• Un contenitore associativo di coppie, in quanto i valori dei dati degli elementi sono diversi dai valori delle relative chiavi.

• Un modello di classe, perché la funzionalità fornita è generica e quindi indipendente dal tipo specifico di dati contenuti come elementi o chiavi. I tipi di dati da utilizzare per gli elementi e le chiavi vengono invece specificati come parametri nel modello di classe i insieme alla funzione di confronto e all'allocatore.

Il vantaggio principale dell'hashing rispetto all'ordinamento è costituito da una maggiore efficienza. Un hashing corretto esegue inserimenti, eliminazioni e ricerche in un tempo medio costante rispetto al tempo proporzionale al logaritmo del numero di elementi nel contenitore per le tecniche di ordinamento. Il valore di un elemento in un hash_mapoggetto , ma non il relativo valore di chiave associato, può essere modificato direttamente. I valori invece delle chiavi associati a elementi precedenti devono essere eliminati e i valori delle nuove chiavi devono essere associati ai nuovi elementi inseriti.

La scelta del tipo di contenitore deve essere basata in genere sul tipo di ricerca e di inserimento richiesti dall'applicazione. I contenitori associativi con hash sono ottimizzati per le operazioni di ricerca, inserimento e rimozione. Le funzioni membro che supportano in modo esplicito queste operazioni risultano efficienti quando vengono usate con una funzione hash ben progettata, poiché eseguono le operazioni in un tempo mediamente costante e non dipendente dal numero di elementi nel contenitore. Una funzione hash ben progettata produce una distribuzione uniforme di valori con hash e riduce al minimo i numeri di conflitti. Un conflitto si verifica quando viene eseguito il mapping di valori di chiave distinti allo stesso valore con hash. Nella peggiore delle ipotesi, con la peggiore funzione hash possibile, il numero di operazioni è proporzionale al numero di elementi della sequenza (tempo lineare).

Deve hash_map essere il contenitore associativo scelto quando le condizioni che associano i valori alle relative chiavi vengono soddisfatte dall'applicazione. Un modello relativo a questo tipo di struttura è costituito da un elenco ordinato di parole chiave univoche con valori di stringa associati che forniscono, ad esempio, definizioni. Se, invece, le parole avevano più di una definizione corretta, in modo che le chiavi non fossero univoce, sarebbe hash_multimap il contenitore preferito. Se, d'altra parte, solo l'elenco di parole veniva archiviato, sarebbe hash_set il contenitore corretto. Se sono state consentite più occorrenze delle parole, una hash_multiset sarà la struttura del contenitore appropriata.

Ordina hash_map la sequenza che controlla chiamando un oggetto hash Traits archiviato della classe value_compare. È possibile accedere a questo oggetto archiviato chiamando la funzione key_compmembro . Un oggetto funzione di questo tipo deve comportarsi come un oggetto della classe hash_compare<Key, less<Key>>. In particolare, per tutti i valori Key di tipo Key, la chiamata Traits( Key ) genera una distribuzione di valori di tipo size_t. Per ulteriori informazioni, vedere hash_compare.

In generale, gli elementi devono essere semplicemente meno di paragonabili per stabilire questo ordine: in modo che, dato qualsiasi due elementi, possa essere determinato che sono equivalenti (nel senso che nessuno è minore dell'altro) o che uno è minore dell'altro. Di conseguenza, l'ordinamento viene eseguito tra gli elementi non equivalenti. A un livello più tecnico, la funzione di confronto è un predicato binario che provoca un ordinamento di tipo "strict weak" nel senso matematico standard. Un predicato binario f(x y) è un oggetto funzione che dispone di due oggetti argomento, x e y, e di un valore restituito true o false. Un ordinamento imposto a è hash_map un ordinamento debole rigoroso se il predicato binario è irreflessivo, antisymmetrico e transitivo e se l'equivalenza è transitiva, dove due oggetti x e y vengono definiti come equivalenti quando entrambi f(x, y) e f(y, x) sono false. Se la condizione di uguaglianza più forte tra le chiavi sostituisce quella di equivalenza, l'ordinamento diventa totale, in quanto tutti gli elementi vengono ordinati l'uno rispetto all'altro e le chiavi accoppiate saranno indistinguibili l'una dall'altra.

L'ordine effettivo degli elementi nella sequenza controllata dipende dalla funzione hash, dalla funzione di ordinamento e dalle dimensioni correnti della tabella hash archiviata nell'oggetto contenitore. Non è possibile determinare le dimensioni correnti della tabella hash, quindi non è possibile stimare in generale l'ordine degli elementi nella sequenza controllata. L'inserimento di elementi non invalida gli iteratori e la rimozione di tali elementi invalida solo gli iteratori che avevano puntato in modo specifico agli elementi rimossi.

L'iteratore fornito dalla hash_map classe è un iteratore bidirezionale, ma le funzioni insert membro della classe e hash_map hanno versioni che accettano come parametri di modello un iteratore di input più debole, i cui requisiti di funzionalità sono più minimi di quelli garantiti dalla classe di iteratori bidirezionali. I diversi concetti di iteratore formano una famiglia correlata dai perfezionamenti delle relative funzionalità. Ogni concetto di iteratore dispone di un proprio set di requisiti e gli algoritmi utilizzati con tali concetti devono limitare le proprie ipotesi ai requisiti forniti da tale tipo di iteratore. Si può presupporre che un iteratore di input possa essere dereferenziato per fare riferimento a un determinato oggetto e possa essere incrementato all'iteratore successivo nella sequenza. Si tratta di un set minimo di funzionalità, ma è sufficiente essere in grado di parlare significativamente di un intervallo di iteratori [First, Last) nel contesto delle funzioni membro della classe.

Costruttori

Costruttore	Descrizione
hash_map	Costruisce un hash_map vuoto o che rappresenta una copia totale o parziale di un altro hash_map.

Typedef

Nome tipo	Descrizione
allocator_type	Tipo che rappresenta la classe allocator per l'oggetto hash_map.
const_iterator	Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento const nel hash_map.
const_pointer	Tipo che fornisce un puntatore a un elemento const in un hash_map.
const_reference	Tipo che fornisce un riferimento a un elemento const archiviato in un hash_map per la lettura e l'esecuzione di operazioni const.
const_reverse_iterator	Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento const nel hash_map.
difference_type	Tipo Signed Integer che può essere utilizzato per rappresentare il numero di elementi di un hash_map in un intervallo compreso tra gli elementi a cui puntano gli iteratori.
iterator	Tipo che fornisce un iteratore bidirezionale in grado di leggere o modificare qualsiasi elemento di un hash_map.
key_compare	Tipo che fornisce un oggetto funzione in grado di confrontare due chiavi di ordinamento per determinare l'ordine relativo di due elementi nel hash_map.
key_type	Tipo che descrive l'oggetto chiave di ordinamento di cui è costituito ogni elemento del hash_map.
mapped_type	Tipo che rappresenta il tipo di dati archiviati in un hash_map.
pointer	Tipo che fornisce un puntatore a un elemento in un hash_map.
reference	Tipo che fornisce un riferimento a un elemento archiviato in un hash_map.
reverse_iterator	Tipo che fornisce un iteratore bidirezionale in grado di leggere o modificare un elemento di un hash_map invertito.
size_type	Tipo Unsigned Integer in grado di rappresentare il numero di elementi di un hash_map.
value_type	Tipo che fornisce un oggetto funzione in grado di confrontare due elementi come chiavi di ordinamento per determinarne l'ordine relativo nel hash_map.

Funzioni membro

Funzione membro	Descrizione
at	Trova un elemento in un hash_map con un valore di chiave specificato.
begin	Restituisce un iteratore che punta al primo elemento del hash_map.
cbegin	Restituisce un iteratore const che punta al primo elemento del hash_map.
cend	Restituisce un iteratore const che punta alla posizione successiva all'ultimo elemento di un hash_map.
clear	Cancella tutti gli elementi di un hash_map.
count	Restituisce il numero di elementi di un hash_map la cui chiave corrisponde a una chiave specificata dal parametro.
crbegin	Restituisce un const iteratore che punta al primo elemento di un oggetto invertito hash_map.
crend	Restituisce un const iteratore che punta alla posizione successiva all'ultimo elemento di un oggetto invertito hash_map.
emplace	Inserisce un elemento costruito sul posto in un hash_map.
emplace_hint	Inserisce un elemento costruito sul posto in un hash_map, con un suggerimento sulla posizione.
empty	Verifica se un hash_map è vuoto.
end	Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un hash_map.
equal_range	Restituisce una coppia di iteratori rispettivamente al primo elemento di un hash_map con una chiave maggiore di una chiave specificata e al primo elemento di hash_map con una chiave uguale o maggiore di tale chiave.
erase	Rimuove un elemento o un intervallo di elementi di un hash_map dalle posizioni specificate.
find	Restituisce un iteratore che punta alla posizione di un elemento in un hash_map che dispone di una chiave equivalente a una chiave specificata.
get_allocator	Restituisce una copia dell'oggetto allocator utilizzato per costruire il hash_map.
insert	Inserisce un elemento o un intervallo di elementi in un hash_map.
key_comp	Restituisce un iteratore al primo elemento di un hash_map con un valore della chiave uguale o maggiore di quello di una chiave specificata.
lower_bound	Restituisce un iteratore al primo elemento di un hash_map con un valore della chiave uguale o maggiore di quello di una chiave specificata.
max_size	Restituisce la lunghezza massima del hash_map.
rbegin	Restituisce un iteratore che punta al primo elemento di un hash_map invertito.
rend	Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un hash_map invertito.
size	Restituisce il numero di elementi nel hash_map.
swap	Scambia gli elementi di due hash_map.
upper_bound	Restituisce un iteratore al primo elemento di un hash_map con un valore della chiave maggiore di quello di una chiave specificata.
value_comp	Recupera una copia dell'oggetto di confronto usato per ordinare i valori degli elementi di un hash_map.

Operatori

Operatore	Descrizione
operator[]	Inserisce un elemento in un hash_map con un valore di chiave specificato.
hash_map::operator=	Sostituisce gli elementi di un hash_map con una copia di un altro hash_map.

Requisiti

Intestazione: <hash_map>

Spazio dei nomi: stdext

hash_map::allocator_type

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo che rappresenta la classe allocator per l'oggetto hash_map.

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

Esempio

Vedere l'esempio per get_allocator un esempio che usa allocator_type.

hash_map::at

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Trova un elemento in un hash_map con un valore di chiave specificato.

Type& at(const Key& key);

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

Parametri

key
Valore della chiave dell'elemento da trovare.

Valore restituito

Riferimento al valore dei dati dell'elemento trovato.

Osservazioni:

Se il valore della chiave dell'argomento non viene trovato, la funzione genera un oggetto della classe out_of_range Class.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce un iteratore che punta al primo elemento del hash_map.

const_iterator begin() const;

iterator begin();

Valore restituito

Iteratore bidirezionale che punta al primo elemento nell'oggetto hash_map o alla posizione successiva a un oggetto vuoto hash_map.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce un iteratore const che punta al primo elemento del hash_map.

const_iterator cbegin() const;

Valore restituito

Iteratore bidirezionale const che punta al primo elemento nell'oggetto hash_map o alla posizione successiva a un oggetto vuoto hash_map.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce un iteratore const che punta alla posizione successiva all'ultimo elemento di un hash_map.

const_iterator cend() const;

Valore restituito

Iteratore bidirezionale const che punta alla posizione successiva all'ultimo elemento di un oggetto hash_map. Se l'oggetto hash_map è vuoto, hash_map::cend == hash_map::begin.

Osservazioni:

cend viene usato per verificare se un iteratore ha raggiunto la fine del relativo oggetto hash_map.

Il valore restituito da cend non deve essere dereferenziato.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Cancella tutti gli elementi di un hash_map.

void clear();

Osservazioni:

Esempio

Nell'esempio seguente viene illustrato l'uso della hash_map::clear funzione membro.

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento const nel hash_map.

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

Osservazioni:

Non è possibile usare un tipo const_iterator per modificare il valore di un elemento.

L'oggetto const_iterator definito da hash_map punta a elementi di value_type, ovvero di tipo pair< const Key, Type >, il cui primo membro è la chiave dell'elemento e il cui secondo membro è il datum mappato mantenuto dall'elemento .

Per dereferenziare un const_iterator cIter elemento in un hash_mapoggetto , usare l'operatore -> .

Per accedere al valore della chiave per l'elemento, usare cIter->first, equivalente a (*cIter).first. Per accedere al valore del datum mappato per l'elemento, usare cIter->second, che equivale a (*cIter).second.

Esempio

Vedere l'esempio per begin un esempio che usa const_iterator.

hash_map::const_pointer

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo che fornisce un puntatore a un elemento const in un hash_map.

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

Osservazioni:

Non è possibile usare un tipo const_pointer per modificare il valore di un elemento.

Nella maggior parte dei casi, un oggetto iterator deve essere utilizzato per accedere agli elementi in un hash_map oggetto .

hash_map::const_reference

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo che fornisce un riferimento a un elemento const archiviato in un hash_map per la lettura e l'esecuzione di operazioni const.

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

Osservazioni:

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento const nel hash_map.

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

Osservazioni:

Un tipo const_reverse_iterator non può modificare il valore di un elemento e viene usato per scorrere l'oggetto hash_map inverso.

L'oggetto const_reverse_iterator definito da hash_map punta a elementi di value_type, ovvero di tipo pair< const Key, Type >, il cui primo membro è la chiave dell'elemento e il cui secondo membro è il datum mappato mantenuto dall'elemento .

Per dereferenziare un const_reverse_iterator crIter elemento in un hash_mapoggetto , usare l'operatore -> .

Per accedere al valore della chiave per l'elemento, usare crIter->first, equivalente a (*crIter).first. Per accedere al valore del datum mappato per l'elemento, usare crIter->second, che equivale a (*crIter).first.

Esempio

Vedere l'esempio per rend un esempio di come dichiarare e usare .const_reverse_iterator

hash_map::count

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce il numero di elementi di un hash_map la cui chiave corrisponde a una chiave specificata dal parametro.

size_type count(const Key& key) const;

Parametri

key
Valore chiave degli elementi di cui trovare la corrispondenza dall'oggetto hash_map.

Valore restituito

1 se hash_map contiene un elemento la cui chiave di ordinamento corrisponde alla chiave del parametro; 0 se non hash_map contiene un elemento con una chiave corrispondente.

Osservazioni:

La funzione membro restituisce il numero di elementi x nell'intervallo

lower_bound(key), upper_bound(key)

che è 0 o 1 nel caso di hash_map, che è un contenitore associativo univoco.

Esempio

Nell'esempio seguente viene illustrato l'uso della hash_map::count funzione membro.

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce un const iteratore che punta al primo elemento di un oggetto invertito hash_map.

const_reverse_iterator crbegin() const;

Valore restituito

Iteratore const bidirezionale inverso che punta al primo elemento in un oggetto hash_map invertito o che punta a ciò che era stato l'ultimo elemento nell'oggetto non invertito hash_map.

Osservazioni:

crbegin viene usato con un oggetto invertito hash_map esattamente come begin viene usato con un oggetto hash_map.

Con il valore restituito di crbegin, l'oggetto hash_map non può essere modificato.

crbegin può essere usato per eseguire l'iterazione all'indietro su un oggetto hash_map.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce un const iteratore che punta alla posizione successiva all'ultimo elemento di un oggetto invertito hash_map.

const_reverse_iterator crend() const;

Valore restituito

Iteratore const bidirezionale inverso che punta alla posizione successiva all'ultimo elemento di un oggetto invertito (la posizione che aveva preceduto hash_map il primo elemento nell'oggetto non invertito hash_map).

Osservazioni:

crend viene usato con un oggetto invertito hash_map esattamente come hash_map::end viene usato con un oggetto hash_map.

Con il valore restituito di crend, l'oggetto hash_map non può essere modificato.

crend può essere usato per verificare se un iteratore inverso ha raggiunto la fine dell'oggetto hash_map.

Il valore restituito da crend non deve essere dereferenziato.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo Signed Integer che può essere utilizzato per rappresentare il numero di elementi di un hash_map in un intervallo compreso tra gli elementi a cui puntano gli iteratori.

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

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Inserisce un elemento costruito sul posto in un hash_map.

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

Parametri

val
Valore utilizzato per spostare un elemento da inserire nell'oggetto hash_map a meno che non hash_map contenga già tale elemento (o, più in generale, un elemento la cui chiave è ordinata in modo equivalente).

Valore restituito

La emplace funzione membro restituisce una coppia il cui bool componente restituisce true se è stato effettuato un inserimento e false se l'elemento hash_map contiene già un elemento la cui chiave ha un valore equivalente nell'ordinamento e il cui iterator componente restituisce l'indirizzo in cui è stato inserito un nuovo elemento o in cui si trovava già l'elemento.

Per accedere al componente iterator di una coppia pr restituita da questa funzione membro, usare pr.first e per dereferenziarlo, usare *(pr.first). Per accedere al componente bool di una coppia pr restituita da questa funzione membro, usare pr.second e per dereferenziarlo, usare *(pr.second).

Osservazioni:

L'oggetto hash_map::value_type di un elemento è una coppia, in modo che il valore di un elemento sia una coppia ordinata con il primo componente uguale al valore della chiave e il secondo componente uguale al valore di dati dell'elemento.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Inserisce un elemento costruito sul posto in un hash_map, con un suggerimento sulla posizione.

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

Parametri

val
Valore utilizzato per spostare un elemento da inserire nell'oggetto hash_map a meno che non hash_map contenga già tale elemento (o, più in generale, un elemento la cui chiave è ordinata in modo equivalente).

c
Suggerimento sulla posizione per avviare la ricerca del punto di inserimento corretto.

Valore restituito

La hash_multimap::emplace funzione membro restituisce un iteratore che punta alla posizione in cui è stato inserito il nuovo elemento nell'oggetto hash_mapo in cui si trova l'elemento esistente con ordinamento equivalente.

Osservazioni:

L'oggetto hash_map::value_type di un elemento è una coppia, in modo che il valore di un elemento sia una coppia ordinata con il primo componente uguale al valore della chiave e il secondo componente uguale al valore di dati dell'elemento.

Se il punto di inserimento è immediatamente successivo a _Where, l'inserimento può avvenire in tempo costante ammortizzato anziché in tempo logaritmico.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Verifica se un hash_map è vuoto.

bool empty() const;

Valore restituito

true se l'oggetto hash_map è vuoto; false se l'oggetto hash_map è non vuoto.

Osservazioni:

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un hash_map.

const_iterator end() const;

iterator end();

Valore restituito

Iteratore bidirezionale che punta alla posizione successiva all'ultimo elemento di un oggetto hash_map. Se l'oggetto hash_map è vuoto, hash_map::end == hash_map::begin.

Osservazioni:

end viene usato per verificare se un iteratore ha raggiunto la fine del relativo oggetto hash_map.

Il valore restituito da end non deve essere dereferenziato.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce una coppia di iteratori rispettivamente al primo elemento di un hash_map con una chiave maggiore di una chiave specificata e al primo elemento di hash_map con una chiave uguale o maggiore di tale chiave.

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

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

Parametri

key
Valore della chiave dell'argomento hash_map da confrontare con la chiave di ordinamento di un elemento dalla ricerca.

Valore restituito

Coppia di iteratori in modo che il primo sia la lower_bound chiave e la seconda sia la upper_bound chiave.

Per accedere al primo iteratore di una coppia pr restituita dalla funzione membro, usare pr.first e per dereferenziare l'iteratore associato inferiore, usare *(pr.first). Per accedere al secondo iteratore di una coppia pr restituita dalla funzione membro, usare pr.second e per dereferenziare l'iteratore superiore associato, usare *(pr.second).

Osservazioni:

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Rimuove un elemento o un intervallo di elementi di un hash_map dalle posizioni specificate oppure rimuove gli elementi che corrispondono a una chiave specificata.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Parametri

_Where
Posizione dell'elemento da rimuovere da hash_map.

first
Posizione del primo elemento rimosso da hash_map.

last
Posizione immediatamente successiva all'ultimo elemento rimosso da hash_map.

key
Valore della chiave degli elementi da rimuovere da hash_map.

Valore restituito

Per le prime due funzioni membro, un iteratore bidirezionale che definisce il primo elemento rimanente oltre qualsiasi elemento rimosso o un puntatore alla fine di hash_map se tale elemento non esiste.

Per la terza funzione membro, restituisce il numero di elementi rimossi da hash_map.

Osservazioni:

Le funzioni membro non generano mai un'eccezione.

Esempio

Nell'esempio seguente viene illustrato l'uso della hash_map::erase funzione membro.

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce un iteratore che punta alla posizione di un elemento in un hash_map che dispone di una chiave equivalente a una chiave specificata.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametri

key
Valore della chiave da trovare in base alla chiave di ordinamento di un elemento dall'oggetto di cui viene eseguita la hash_map ricerca.

Valore restituito

Iteratore che punta alla posizione di un elemento con una chiave specificata o la posizione successiva all'ultimo elemento in hash_map se non viene trovata alcuna corrispondenza per la chiave.

Osservazioni:

find restituisce un iteratore che punta a un elemento nella hash_map cui chiave di ordinamento è equivalente alla chiave dell'argomento in un predicato binario che induce un ordinamento basato su una relazione di confronto minore di.

Se il valore restituito di find viene assegnato a un const_iteratoroggetto , l'oggetto hash_map non può essere modificato. Se il valore restituito di find viene assegnato a un iteratoroggetto , l'oggetto hash_map può essere modificato

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce una copia dell'oggetto allocatore utilizzato per costruire l'oggetto hash_map.

Allocator get_allocator() const;

Valore restituito

Allocatore utilizzato dall'oggetto hash_map.

Osservazioni:

Gli allocatori per la hash_map classe specificano il modo in cui la classe gestisce l'archiviazione. Gli allocatori predefiniti acclusi alle classi contenitore della libreria standard C++ sono sufficienti per la maggior parte delle esigenze di programmazione. Scrivere e usare una classe allocator personalizzata è un argomento di C++ avanzato.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Costruisce un oggetto hash_map vuoto o è una copia di tutto o parte di un altro hash_mapoggetto .

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

Parametri

Al
Classe dell'allocatore di memoria da usare per l'oggetto hash_map. Per impostazione predefinita è Allocator.

Comp
Funzione di confronto di tipo const Traits usata per ordinare gli elementi in hash_map, che per impostazione predefinita è hash_compare.

Right
Oggetto hash_map di cui la mappa costruita deve essere una copia.

First
Posizione del primo elemento nell'intervallo di elementi da copiare.

Last
Posizione del primo elemento oltre l'intervallo di elementi da copiare.

IList
Oggetto initializer_list

Osservazioni:

Tutti i costruttori archiviano un tipo di oggetto allocatore che gestisce l'archiviazione hash_map di memoria per e possono essere restituiti in un secondo momento chiamando get_allocator. Il parametro allocator viene spesso omesso nelle dichiarazioni di classe e vengono usate macro di pre-elaborazione per introdurre allocatori alternativi.

Tutti i costruttori inizializzano il relativo hash_mapoggetto .

Tutti i costruttori archiviano un oggetto funzione di tipo Traits utilizzato per stabilire un ordine tra le chiavi di hash_map e che possono essere restituiti in un secondo momento chiamando key_comp.

I primi tre costruttori specificano anche un oggetto iniziale hash_mapvuoto, il secondo specifica il tipo di funzione di confronto (Comp) da usare per stabilire l'ordine degli elementi e il terzo specifica in modo esplicito il tipo di allocatore (Al) da usare. La parola chiave explicit elimina alcuni tipi di conversione automatica del tipo.

Il quarto costruttore specifica una copia dell'oggetto hash_map Right.

I tre costruttori successivi copiano l'intervallo [First, Last) di un hash_map oggetto con maggiore esplicitità specificando il tipo di funzione di confronto della classe Traits e dell'allocatore.

L'ultimo costruttore sposta .hash_map Right

hash_map::insert

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Inserisce un elemento o un intervallo di elementi in un hash_map.

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);

Parametri

val
Valore di un elemento da inserire nell'oggetto hash_map a meno che non hash_map contenga già tale elemento (o, più in generale, un elemento la cui chiave è ordinata in modo equivalente).

_Where
Suggerimento sulla posizione per avviare la ricerca del punto di inserimento corretto.

first
Posizione del primo elemento da copiare da un oggetto hash_map.

last
Posizione immediatamente dopo l'ultimo elemento da copiare da un oggetto hash_map.

Valore restituito

La prima insert funzione membro restituisce una coppia il cui bool componente restituisce true se è stato eseguito un inserimento e false se l'elemento hash_map contiene già un elemento la cui chiave ha un valore equivalente nell'ordinamento e il cui componente iteratore restituisce l'indirizzo in cui è stato inserito un nuovo elemento o in cui l'elemento era già posizionato.

Per accedere al componente iteratore di una coppia pr restituita da questa funzione membro, usare pr.first e per deferenziarlo, usare (pr.first). Per accedere al componente bool di una coppia pr restituita da questa funzione membro, usare pr.second e per dereferenziarlo, usare \(pr.second).

La seconda insert funzione membro, la versione dell'hint, restituisce un iteratore che punta alla posizione in cui è stato inserito il nuovo elemento nell'oggetto hash_map.

Le ultime due insert funzioni membro si comportano come le prime due, ad eccezione del fatto che spostano il valore inserito.

Osservazioni:

L'oggetto value_type di un elemento è una coppia, in modo che il valore di un elemento sia una coppia ordinata con il primo componente uguale al valore della chiave e il secondo componente uguale al valore di dati dell'elemento.

Se il punto di inserimento è immediatamente successivo a _Where, l'inserimento per la versione del suggerimento di insert può avvenire in tempo costante ammortizzato anziché in tempo logaritmico.

La terza funzione membro inserisce la sequenza di valori di elemento in un hash_map oggetto corrispondente a ogni elemento indirizzato da un iteratore di nell'intervallo *[First, Last)* di un set specificato.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo che fornisce un iteratore bidirezionale in grado di leggere o modificare qualsiasi elemento di un hash_map.

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

Osservazioni:

L'oggetto iterator definito da hash_map punta a elementi di value_type, ovvero di tipo pair<const Key, Type>, il cui primo membro è la chiave dell'elemento e il cui secondo membro è il datum mappato mantenuto dall'elemento .

Per dereferenziare un iteratore denominato Iter che punta a un elemento in un oggetto multimap, usare l'operatore -> .

Per accedere al valore della chiave per l'elemento, usare Iter->first, equivalente a (*Iter).first. Per accedere al valore del datum mappato per l'elemento, usare Iter->second, che equivale a (*Iter).second.

È possibile utilizzare un tipo iterator per modificare il valore di un elemento.

Esempio

Vedere l'esempio per begin un esempio di come dichiarare e usare .iterator

hash_map::key_comp

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Recupera una copia dell'oggetto di confronto utilizzato per ordinare le chiavi di un hash_map.

key_compare key_comp() const;

Valore restituito

Restituisce l'oggetto funzione utilizzato da un hash_map oggetto per ordinare i relativi elementi.

Osservazioni:

L'oggetto archiviato definisce la funzione membro

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

che restituisce true se left precede e non è uguale a right nell'ordinamento.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo che fornisce un oggetto funzione in grado di confrontare due chiavi di ordinamento per determinare l'ordine relativo di due elementi nell'oggetto map.

typedef Traits key_compare;

Osservazioni:

key_compare è un sinonimo per il parametro di modello Traits.

Per altre informazioni sull'argomento Traitshash_map Classe.

Esempio

Vedere l'esempio per key_comp un esempio di come dichiarare e usare key_compare.

hash_map::key_type

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo che descrive l'oggetto chiave di ordinamento di cui è costituito ogni elemento del hash_map.

typedef Key key_type;

Osservazioni:

key_type è un sinonimo per il parametro di modello Key.

Per altre informazioni su Key, vedere la sezione Osservazioni dell'argomento hash_map Classe .

Esempio

Vedere l'esempio per value_type un esempio di come dichiarare e usare key_type.

hash_map::lower_bound

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce un iteratore al primo elemento di un hash_map con un valore della chiave uguale o maggiore di quello di una chiave specificata.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parametri

key
Valore della chiave dell'argomento hash_map da confrontare con la chiave di ordinamento di un elemento dalla ricerca.

Valore restituito

Oggetto iterator o const_iterator che punta alla posizione di un elemento in un hash_map oggetto con una chiave uguale o maggiore della chiave dell'argomento oppure che punta alla posizione successiva all'ultimo elemento in hash_map se non viene trovata alcuna corrispondenza per la chiave.

Se il valore restituito di lower_bound viene assegnato a un const_iteratoroggetto , l'oggetto hash_map non può essere modificato. Se il valore restituito di lower_bound viene assegnato a un iteratoroggetto , l'oggetto hash_map può essere modificato.

Osservazioni:

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo che rappresenta il tipo di dati archiviati in un hash_map.

typedef Type mapped_type;

Osservazioni:

Il tipo mapped_type è un sinonimo per il parametro di modello Type.

Per altre informazioni sull'argomento Typehash_map Classe.

Esempio

Vedere l'esempio per value_type un esempio di come dichiarare e usare key_type.

hash_map::max_size

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce la lunghezza massima del hash_map.

size_type max_size() const;

Valore restituito

Lunghezza massima possibile dell'oggetto hash_map.

Osservazioni:

Esempio

// 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[]

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Inserisce un elemento in un hash_map con un valore di chiave specificato.

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

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

Parametri

key
Valore della chiave dell'elemento da inserire.

Valore restituito

Riferimento al valore dei dati dell'elemento inserito.

Osservazioni:

Se il valore della chiave dell'argomento non viene trovato, viene inserito insieme al valore predefinito del tipo di dati.

operator[] può essere usato per inserire elementi in un oggetto hash_map m tramite

m[ key] = DataValue;

dove DataValue è il valore del tipo mapped_type dell'elemento con valore di chiave key.

Quando si usa operator[] per inserire elementi, il riferimento restituito non indica se un inserimento sta modificando un elemento preesistente o creandone uno nuovo. Le funzioni find membro e insert possono essere utilizzate per determinare se un elemento con una chiave specificata è già presente prima di un inserimento.

Esempio

// 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=

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Sostituisce gli elementi di una hash_map con una copia di un'altra hash_map.

hash_map& operator=(const hash_map& right);

hash_map& operator=(hash_map&& right);

Parametri

right
Classe right copiata nell'oggetto hash_map.

Osservazioni:

Dopo la cancellazione di tutti gli elementi esistenti in un oggetto hash_map, operator= copia o sposta il contenuto di right nell'oggetto hash_map.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo che fornisce un puntatore a un elemento in un hash_map.

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

Osservazioni:

È possibile utilizzare un tipo pointer per modificare il valore di un elemento.

Nella maggior parte dei casi, un oggetto iterator deve essere utilizzato per accedere agli elementi in un hash_map oggetto .

hash_map::rbegin

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce un iteratore che punta al primo elemento di un hash_map invertito.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valore restituito

Iteratore bidirezionale inverso che punta al primo elemento in un oggetto hash_map invertito o che punta a ciò che era stato l'ultimo elemento nell'oggetto non invertito hash_map.

Osservazioni:

rbegin viene usato con un oggetto invertito hash_map esattamente come begin viene usato con un oggetto hash_map.

Se il valore restituito di rbegin viene assegnato a un const_reverse_iteratoroggetto , l'oggetto hash_map non può essere modificato. Se il valore restituito di rbegin viene assegnato a un reverse_iteratoroggetto , l'oggetto hash_map può essere modificato.

rbegin può essere usato per eseguire l'iterazione all'indietro su un oggetto hash_map.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo che fornisce un riferimento a un elemento archiviato in un hash_map.

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

Osservazioni:

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un hash_map invertito.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valore restituito

Iteratore bidirezionale inverso che punta alla posizione successiva all'ultimo elemento di un oggetto invertito (la posizione che aveva preceduto hash_map il primo elemento nell'oggetto non invertito hash_map).

Osservazioni:

rend viene usato con un oggetto invertito hash_map esattamente come end viene usato con un oggetto hash_map.

Se il valore restituito di rend viene assegnato a un const_reverse_iteratoroggetto , l'oggetto hash_map non può essere modificato. Se il valore restituito di rend viene assegnato a un reverse_iteratoroggetto , l'oggetto hash_map può essere modificato.

rend può essere usato per verificare se un iteratore inverso ha raggiunto la fine dell'oggetto hash_map.

Il valore restituito da rend non deve essere dereferenziato.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo che fornisce un iteratore bidirezionale in grado di leggere o modificare un elemento di un hash_map invertito.

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

Osservazioni:

Un tipo reverse_iterator non può modificare il valore di un elemento e viene usato per scorrere l'oggetto hash_map inverso.

Oggetto reverse_iterator definito da hash_map punti agli elementi che sono oggetti di value_type, ovvero di tipo pair<const Key, Type>, il cui primo membro è la chiave dell'elemento e il cui secondo membro è il datum mappato mantenuto dall'elemento .

Per dereferenziare un reverse_iterator rIter elemento in un hash_mapoggetto , usare l'operatore -> .

Per accedere al valore della chiave per l'elemento, usare rIter->first, equivalente a (*rIter).first. Per accedere al valore del datum mappato per l'elemento, usare rIter->second, che equivale a (*rIter).first.

Esempio

Vedere l'esempio per rbegin un esempio di come dichiarare e usare reverse_iterator.

hash_map::size

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce il numero di elementi nel hash_map.

size_type size() const;

Valore restituito

Lunghezza corrente dell'oggetto hash_map.

Osservazioni:

Esempio

Nell'esempio seguente viene illustrato l'uso della hash_map::size funzione membro.

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo Unsigned Integer in grado di rappresentare il numero di elementi di un hash_map.

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

Osservazioni:

Esempio

Vedere l'esempio per size un esempio di come dichiarare e usare size_type

hash_map::swap

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Scambia gli elementi di due hash_map.

void swap(hash_map& right);

Parametri

right
Argomento hash_map che fornisce gli elementi da scambiare con la destinazione hash_map.

Osservazioni:

La funzione membro non invalida riferimenti, puntatori o iteratori che designano gli elementi nei due hash_mapelementi i cui elementi vengono scambiati.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce un iteratore al primo elemento di un hash_map oggetto con una chiave con un valore maggiore di quello di una chiave specificata.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parametri

key
Valore della chiave dell'argomento hash_map da confrontare con il valore della chiave di ordinamento di un elemento dalla ricerca.

Valore restituito

Oggetto iterator o const_iterator che punta alla posizione di un elemento in un hash_map oggetto con una chiave maggiore della chiave dell'argomento oppure che punta alla posizione successiva all'ultimo elemento in hash_map se non viene trovata alcuna corrispondenza per la chiave.

Se il valore restituito viene assegnato a un const_iteratoroggetto , l'oggetto hash_map non può essere modificato. Se il valore restituito viene assegnato a un iteratoroggetto , l'oggetto hash_map può essere modificato.

Osservazioni:

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Restituisce un oggetto funzione che determina l'ordine degli elementi in un hash_map oggetto confrontando i relativi valori di chiave.

value_compare value_comp() const;

Valore restituito

Restituisce l'oggetto funzione di confronto utilizzato da un hash_map oggetto per ordinare i relativi elementi.

Osservazioni:

Per un hash_map moggetto , se due elementi e1 (k1, d1) e e2 (k2, d2) sono oggetti di tipo value_type, dove k1 e k2 sono le relative chiavi di tipo e d1 e d2 sono i relativi dati di tipo key_type mapped_type, allora m.value_comp()(e1, e2) è equivalente a m.key_comp()(k1, k2). Un oggetto archiviato definisce la funzione membro

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

che restituisce true se il valore della chiave di left precede e non è uguale al valore della chiave di right nell'ordinamento.

Esempio

// 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

Nota

Questa API è obsoleta. L'alternativa è unordered_map Class.

Tipo che rappresenta il tipo di oggetto archiviato in un oggetto hash_map.

typedef pair<const Key, Type> value_type;

Osservazioni:

value_type è dichiarato come e pair<const key_type, mapped_type> non pair<key_type, mapped_type> perché le chiavi di un contenitore associativo potrebbero non essere modificate usando un iteratore o un riferimento non costante.

Esempio

// 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.

Vedi anche

Thread Safety in the C++ Standard Library (Sicurezza dei thread nella libreria standard C++)
Informazioni di riferimento per la libreria standard C++