hash_map (STL/CLR)hash_map (STL/CLR)

La classe modello descrive un oggetto che controlla una sequenza di lunghezza variabile di elementi che dispone dell'accesso bidirezionale.The template class describes an object that controls a varying-length sequence of elements that has bidirectional access. Usare il contenitore hash_map per gestire una sequenza di elementi come una tabella hash, ogni voce della tabella archiviare un bidirezionale elenco di nodi e ogni nodo di archiviazione di un elemento collegato.You use the container hash_map to manage a sequence of elements as a hash table, each table entry storing a bidirectional linked list of nodes, and each node storing one element. Un elemento è costituito da una chiave, per ordinare la sequenza e il valore mappato, che si estende per la corsa.An element consists of a key, for ordering the sequence, and a mapped value, which goes along for the ride.

Nella sezione successiva, GValue equivale a:In the description below, GValue is the same as:

Microsoft::VisualC::StlClr::GenericPair<GKey, GMapped>

dove:where:

GKey equivale a Key , a meno che quest'ultimo è un tipo riferimento, nel qual caso è Key^GKey is the same as Key unless the latter is a ref type, in which case it is Key^

GMapped equivale a Mapped , a meno che quest'ultimo è un tipo riferimento, nel qual caso è Mapped^GMapped is the same as Mapped unless the latter is a ref type, in which case it is Mapped^

SintassiSyntax

template<typename Key,
    typename Mapped>
    ref class hash_map
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        System::Collections::Generic::IDictionary<Gkey, GMapped>,
        Microsoft::VisualC::StlClr::IHash<Gkey, GValue>
    { ..... };

ParametriParameters

KeyKey
Il tipo del componente chiave di un elemento nella sequenza controllata.The type of the key component of an element in the controlled sequence.

Il mappingMapped
Il tipo del componente aggiuntivo di un elemento nella sequenza controllata.The type of the additional component of an element in the controlled sequence.

RequisitiRequirements

Intestazione: <cliext/hash_map >Header: <cliext/hash_map>

Namespace: cliextNamespace: cliext

DichiarazioniDeclarations

Definizione dei tipiType Definition DescrizioneDescription
hash_map::const_iterator (STL/CLR)hash_map::const_iterator (STL/CLR) Tipo di un iteratore costante per la sequenza controllata.The type of a constant iterator for the controlled sequence.
hash_map::const_reference (STL/CLR)hash_map::const_reference (STL/CLR) Tipo di un riferimento costante a un elemento.The type of a constant reference to an element.
hash_map::const_reverse_iterator (STL/CLR)hash_map::const_reverse_iterator (STL/CLR) Tipo di un iteratore inverso costante per la sequenza controllata.The type of a constant reverse iterator for the controlled sequence.
hash_map::difference_type (STL/CLR)hash_map::difference_type (STL/CLR) Tipo di una distanza (possibilmente con segno) tra due elementi.The type of a (possibly signed) distance between two elements.
hash_map::generic_container (STL/CLR)hash_map::generic_container (STL/CLR) Il tipo dell'interfaccia generica per il contenitore.The type of the generic interface for the container.
hash_map::generic_iterator (STL/CLR)hash_map::generic_iterator (STL/CLR) Tipo di iteratore per l'interfaccia generica per il contenitore.The type of an iterator for the generic interface for the container.
hash_map::generic_reverse_iterator (STL/CLR)hash_map::generic_reverse_iterator (STL/CLR) Tipo di iteratore inverso per l'interfaccia generica per il contenitore.The type of a reverse iterator for the generic interface for the container.
hash_map::generic_value (STL/CLR)hash_map::generic_value (STL/CLR) Il tipo di un elemento per l'interfaccia generica per il contenitore.The type of an element for the generic interface for the container.
hash_map::hasher (STL/CLR)hash_map::hasher (STL/CLR) Il delegato hash per una chiave.The hashing delegate for a key.
hash_map::iterator (STL/CLR)hash_map::iterator (STL/CLR) Tipo di un iteratore per la sequenza controllata.The type of an iterator for the controlled sequence.
hash_map::key_compare (STL/CLR)hash_map::key_compare (STL/CLR) Delegato di ordinamento per due chiavi.The ordering delegate for two keys.
hash_map::key_type (STL/CLR)hash_map::key_type (STL/CLR) Tipo di una chiave di ordinamento.The type of an ordering key.
hash_map::mapped_type (STL/CLR)hash_map::mapped_type (STL/CLR) Il tipo del valore mappato associato a ogni chiave.The type of the mapped value associated with each key.
hash_map::reference (STL/CLR)hash_map::reference (STL/CLR) Tipo di un riferimento a un elemento.The type of a reference to an element.
hash_map::reverse_iterator (STL/CLR)hash_map::reverse_iterator (STL/CLR) Tipo di un iteratore inverso della sequenza controllata.The type of a reverse iterator for the controlled sequence.
hash_map::size_type (STL/CLR)hash_map::size_type (STL/CLR) Tipo di una distanza (positivo) tra due elementi.The type of a (non-negative) distance between two elements.
hash_map::value_compare (STL/CLR)hash_map::value_compare (STL/CLR) Delegato di ordinamento per due valori di elemento.The ordering delegate for two element values.
hash_map::value_type (STL/CLR)hash_map::value_type (STL/CLR) Tipo di un elemento.The type of an element.
Funzione membroMember Function DescrizioneDescription
hash_map::begin (STL/CLR)hash_map::begin (STL/CLR) Indica l'inizio della sequenza controllata.Designates the beginning of the controlled sequence.
hash_map::bucket_count (STL/CLR)hash_map::bucket_count (STL/CLR) Conta il numero di bucket.Counts the number of buckets.
hash_map::clear (STL/CLR)hash_map::clear (STL/CLR) Rimuove tutti gli elementi.Removes all elements.
hash_map::count (STL/CLR)hash_map::count (STL/CLR) Conta elementi corrispondenti a una chiave specificata.Counts elements matching a specified key.
hash_map::empty (STL/CLR)hash_map::empty (STL/CLR) Verifica se sono presenti o meno degli elementi.Tests whether no elements are present.
hash_map::end (STL/CLR)hash_map::end (STL/CLR) Designa la fine della sequenza controllata.Designates the end of the controlled sequence.
hash_map::equal_range (STL/CLR)hash_map::equal_range (STL/CLR) Trova un intervallo che corrisponde a una chiave specificata.Finds range that matches a specified key.
hash_map::erase (STL/CLR)hash_map::erase (STL/CLR) Rimuove gli elementi in corrispondenza delle posizioni specificate.Removes elements at specified positions.
hash_map::find (STL/CLR)hash_map::find (STL/CLR) Trova un elemento che corrisponde a una chiave specificata.Finds an element that matches a specified key.
hash_map::hash_delegate (STL/CLR)hash_map::hash_delegate (STL/CLR) Copia il delegato di hash per una chiave.Copies the hashing delegate for a key.
hash_map::hash_map (STL/CLR)hash_map::hash_map (STL/CLR) Costruisce un oggetto contenitore.Constructs a container object.
hash_map::insert (STL/CLR)hash_map::insert (STL/CLR) Aggiunge elementi.Adds elements.
hash_map::key_comp (STL/CLR)hash_map::key_comp (STL/CLR) Copia il delegato di ordinamento per due chiavi.Copies the ordering delegate for two keys.
hash_map::load_factor (STL/CLR)hash_map::load_factor (STL/CLR) Conta il numero medio di elementi per bucket.Counts the average elements per bucket.
hash_map::lower_bound (STL/CLR)hash_map::lower_bound (STL/CLR) Trova l'inizio dell'intervallo che corrisponde a una chiave specificata.Finds beginning of range that matches a specified key.
hash_map::make_value (STL/CLR)hash_map::make_value (STL/CLR) Costruisce un oggetto valore.Constructs a value object.
hash_map::max_load_factor (STL/CLR)hash_map::max_load_factor (STL/CLR) Ottiene o imposta il numero massimo di elementi per bucket.Gets or sets the maximum elements per bucket.
hash_map::rbegin (STL/CLR)hash_map::rbegin (STL/CLR) Indica l'inizio della sequenza controllata inversa.Designates the beginning of the reversed controlled sequence.
hash_map::rehash (STL/CLR)hash_map::rehash (STL/CLR) Ricompila la tabella hash.Rebuilds the hash table.
hash_map::rend (STL/CLR)hash_map::rend (STL/CLR) Indica la fine della sequenza controllata inversa.Designates the end of the reversed controlled sequence.
hash_map::size (STL/CLR)hash_map::size (STL/CLR) Conta il numero di elementi.Counts the number of elements.
hash_map::swap (STL/CLR)hash_map::swap (STL/CLR) Scambia il contenuto di due contenitori.Swaps the contents of two containers.
hash_map::to_array (STL/CLR)hash_map::to_array (STL/CLR) Copia la sequenza controllata in una nuova matrice.Copies the controlled sequence to a new array.
hash_map::upper_bound (STL/CLR)hash_map::upper_bound (STL/CLR) Trova fine dell'intervallo che corrisponde a una chiave specificata.Finds end of range that matches a specified key.
hash_map::value_comp (STL/CLR)hash_map::value_comp (STL/CLR) Copia il delegato di ordinamento per due valori di elemento.Copies the ordering delegate for two element values.
OperatoreOperator DescrizioneDescription
hash_map::operator= (STL/CLR)hash_map::operator= (STL/CLR) Sostituisce la sequenza controllata.Replaces the controlled sequence.
hash_map::operator(STL/CLR)hash_map::operator(STL/CLR) Esegue il mapping di una chiave per il relativo valore mappato associato.Maps a key to its associated mapped value.

InterfacceInterfaces

InterfacciaInterface DescrizioneDescription
ICloneable Duplicare un oggetto.Duplicate an object.
IEnumerable Tramite gli elementi di sequenza.Sequence through elements.
ICollection Gestione gruppo di elementi.Maintain group of elements.
IEnumerable<T> La sequenza tramite elementi tipizzati.Sequence through typed elements.
ICollection<T> Gestione gruppo di elementi tipizzati.Maintain group of typed elements.
IDictionary<TKey, TValue> Gestione gruppo di {chiave, valore} coppie.Maintain group of {key, value} pairs.
IHash < chiave, valore >IHash<Key, Value> Mantenere contenitore generico.Maintain generic container.

NoteRemarks

L'oggetto alloca e libera la memoria per la sequenza che controlla come singoli nodi in un elenco collegato bidirezionale.The object allocates and frees storage for the sequence it controls as individual nodes in a bidirectional linked list. Per velocizzare l'accesso, l'oggetto gestisce una matrice di lunghezza variabile dei puntatori all'elenco (la tabella hash), gestire efficacemente l'intero elenco come una sequenza di sottoelenchi, o bucket.To speed access, the object also maintains a varying-length array of pointers into the list (the hash table), effectively managing the whole list as a sequence of sublists, or buckets. Inserisce gli elementi in un bucket che mantiene ordinato modificando i collegamenti tra nodi, mai copiando i contenuti di un nodo a un altro.It inserts elements into a bucket that it keeps ordered by altering the links between nodes, never by copying the contents of one node to another. Ciò significa che è possibile inserire e rimuovere elementi liberamente senza influenzare gli elementi rimanenti.That means you can insert and remove elements freely without disturbing remaining elements.

L'oggetto Ordina ogni bucket da esso controllata chiamando un oggetto delegato archiviato di tipo hash_set:: key_compare (STL/CLR).The object orders each bucket it controls by calling a stored delegate object of type hash_set::key_compare (STL/CLR). È possibile specificare l'oggetto delegato archiviato quando si costruisce l'oggetto hash_set; Se non si specifica alcun oggetto delegato, il valore predefinito è il confronto operator<=(key_type, key_type).You can specify the stored delegate object when you construct the hash_set; if you specify no delegate object, the default is the comparison operator<=(key_type, key_type).

Accedere all'oggetto delegato archiviato chiamando la funzione membro hash_set:: key_comp (STL/CLR)().You access the stored delegate object by calling the member function hash_set::key_comp (STL/CLR)(). Un oggetto delegato di questo tipo debba definire un ordinamento equivalente tra le chiavi di tipo hash_set:: KEY_TYPE (STL/CLR).Such a delegate object must define equivalent ordering between keys of type hash_set::key_type (STL/CLR). Che significa che, per le due chiavi X e Y:That means, for any two keys X and Y:

key_comp()(X, Y) Restituisce il valore booleano stesso risultato in ogni chiamata.key_comp()(X, Y) returns the same Boolean result on every call.

Se key_comp()(X, Y) && key_comp()(Y, X) è true, quindi X e Y vengono definiti con ordinamento equivalente.If key_comp()(X, Y) && key_comp()(Y, X) is true, then X and Y are said to have equivalent ordering.

Tutte le regole di ordinamento che si comporta come operator<=(key_type, key_type), operator>=(key_type, key_type) o operator==(key_type, key_type) definisce eqivalent ordering.Any ordering rule that behaves like operator<=(key_type, key_type), operator>=(key_type, key_type) or operator==(key_type, key_type) defines eqivalent ordering.

Si noti che il contenitore assicura solo che gli elementi le cui chiavi hanno un ordinamento equivalente (e quale hash con lo stesso valore di numero intero) sono adiacenti all'interno di un bucket.Note that the container ensures only that elements whose keys have equivalent ordering (and which hash to the same integer value) are adjacent within a bucket. A differenza della classe modello hash_multimap (STL/CLR), un oggetto della classe modello hash_map assicura che le chiavi per tutti gli elementi siano univoche.Unlike template class hash_multimap (STL/CLR), an object of template class hash_map ensures that keys for all elements are unique. (Delle due chiavi hanno un ordinamento equivalente.)(No two keys have equivalent ordering.)

L'oggetto determina quale bucket deve contenere una chiave di ordinamento specificata chiamando un oggetto delegato archiviato di tipo hash_set::hasher (STL/CLR).The object determines which bucket should contain a given ordering key by calling a stored delegate object of type hash_set::hasher (STL/CLR). Accedere a questo oggetto archiviato chiamando la funzione membro hash_set::hash_delegate (STL/CLR) () per ottenere un valore intero che dipende dal valore della chiave.You access this stored object by calling the member function hash_set::hash_delegate (STL/CLR)() to obtain an integer value that depends on the key value. È possibile specificare l'oggetto delegato archiviato quando si costruisce l'oggetto hash_set; Se non si specifica alcun oggetto delegato, il valore predefinito è la funzione System::Object::hash_value(key_type).You can specify the stored delegate object when you construct the hash_set; if you specify no delegate object, the default is the function System::Object::hash_value(key_type). Che significa che, per tutte le chiavi X e Y:That means, for any keys X and Y:

hash_delegate()(X) Restituisce lo stesso risultato di integer in ogni chiamata.hash_delegate()(X) returns the same integer result on every call.

Se X e Y hanno un ordinamento equivalente, quindi hash_delegate()(X) deve restituire lo stesso risultato intero hash_delegate()(Y).If X and Y have equivalent ordering, then hash_delegate()(X) should return the same integer result as hash_delegate()(Y).

Ogni elemento contiene una chiave separata e un valore mappato.Each element contains a separate key and a mapped value. La sequenza viene rappresentata in modo da consentire la ricerca, inserimento e rimozione di un elemento arbitrario con un numero di operazioni che è indipendente dal numero di elementi della sequenza (tempo costante): almeno la migliore dei casi.The sequence is represented in a way that permits lookup, insertion, and removal of an arbitrary element with a number of operations that is independent of the number of elements in the sequence (constant time) -- at least in the best of cases. Inoltre, l'inserimento di un elemento non invalida gli iteratori e la rimozione di un elemento invalida solo gli iteratori che fanno riferimento all'elemento rimosso.Moreover, inserting an element invalidates no iterators, and removing an element invalidates only those iterators which point at the removed element.

Se i valori hash non vengono distribuiti in modo uniforme, tuttavia, una tabella hash può degeneri.If hashed values are not uniformly distributed, however, a hash table can degenerate. In casi estremi, per una funzione hash che restituisce sempre lo stesso valore, ricerca, inserimento e rimozione sono proporzionali al numero di elementi della sequenza (tempo lineare).In the extreme -- for a hash function that always returns the same value -- lookup, insertion, and removal are proportional to the number of elements in the sequence (linear time). Il contenitore tenta di scegliere una funzione hash ragionevole, dimensione del bucket mean e dimensioni di tabella hash (numero totale di bucket), ma è possibile ignorare alcune o tutte queste scelte.The container endeavors to choose a reasonable hash function, mean bucket size, and hash-table size (total number of buckets), but you can override any or all of these choices. Vedere, ad esempio, le funzioni hash_set::max_load_factor (STL/CLR) e hash_set::rehash (STL/CLR).See, for example, the functions hash_set::max_load_factor (STL/CLR) and hash_set::rehash (STL/CLR).

Un oggetto hash_map supporta gli iteratori bidirezionali, che significa che è possibile passare agli elementi adiacenti, dato un iteratore che designa un elemento nella sequenza controllata.A hash_map supports bidirectional iterators, which means you can step to adjacent elements given an iterator that designates an element in the controlled sequence. Un nodo head speciale corrisponde all'iteratore restituito da hash_map:: end (STL/CLR)().A special head node corresponds to the iterator returned by hash_map::end (STL/CLR)(). È possibile diminuire l'iteratore per raggiungere l'ultimo elemento nella sequenza controllata, se presente.You can decrement this iterator to reach the last element in the controlled sequence, if present. È possibile incrementare un iteratore di hash_map per raggiungere il nodo head e quindi confronterà uguale a end().You can increment a hash_map iterator to reach the head node, and it will then compare equal to end(). Ma non è possibile dereferenziare l'iteratore restituito da end().But you cannot dereference the iterator returned by end().

Si noti che è possibile fare riferimento a un elemento di hash_map specificato direttamente la posizione numerica, che richiede un iteratore ad accesso casuale.Note that you cannot refer to a hash_map element directly given its numerical position -- that requires a random-access iterator.

Un iteratore di hash_map archivia un handle al relativo nodo hash_map associato, che a sua volta memorizza un handle per il contenitore associato.A hash_map iterator stores a handle to its associated hash_map node, which in turn stores a handle to its associated container. È possibile utilizzare gli iteratori solo con i relativi oggetti contenitore associato.You can use iterators only with their associated container objects. Un iteratore di hash_map rimane valido finché il relativo nodo hash_map associato è associato a un oggetto hash_map.A hash_map iterator remains valid so long as its associated hash_map node is associated with some hash_map. Inoltre, un iteratore valido è dereferenziabile: è possibile usarlo per accedere o modificare il valore dell'elemento che definisce, in modo fino a quando non è uguale a end().Moreover, a valid iterator is dereferencable -- you can use it to access or alter the element value it designates -- so long as it is not equal to end().

La cancellazione o la rimozione di un elemento chiama il distruttore per il valore archiviato.Erasing or removing an element calls the destructor for its stored value. Eliminazione definitiva del contenitore Cancella tutti gli elementi.Destroying the container erases all elements. Un contenitore il cui tipo di elemento è una classe di riferimento in questo modo, assicura che nessun elemento sopravvivere al contenitore.Thus, a container whose element type is a ref class ensures that no elements outlive the container. Si noti, tuttavia, che non è un contenitore di handle non eliminare definitivamente gli elementi.Note, however, that a container of handles does not destroy its elements.

MembriMembers

hash_map::begin (STL/CLR)hash_map::begin (STL/CLR)

Indica l'inizio della sequenza controllata.Designates the beginning of the controlled sequence.

SintassiSyntax

iterator begin();

NoteRemarks

La funzione membro restituisce un iteratore bidirezionale che definisce il primo elemento della sequenza controllata o appena oltre la fine di una sequenza vuota.The member function returns a bidirectional iterator that designates the first element of the controlled sequence, or just beyond the end of an empty sequence. Usarlo per ottenere un iteratore che designa il current inizio della sequenza controllata, ma il cui stato può modificarsi se la lunghezza della sequenza controllata cambia.You use it to obtain an iterator that designates the current beginning of the controlled sequence, but its status can change if the length of the controlled sequence changes.

EsempioExample

// cliext_hash_map_begin.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items
    Myhash_map::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = [{0} {1}]",
        it->first, it->second);
    ++it;
    System::Console::WriteLine("*++begin() = [{0} {1}]",
        it->first, it->second);
    return (0);
    }
[a 1] [b 2] [c 3]
*begin() = [a 1]
*++begin() = [b 2]

hash_map::bucket_count (STL/CLR)hash_map::bucket_count (STL/CLR)

Conta il numero di bucket.Counts the number of buckets.

SintassiSyntax

int bucket_count();

NoteRemarks

La funzione membro restituisce il numero corrente di bucket.The member functions returns the current number of buckets. Utilizzarla per determinare le dimensioni della tabella hash.You use it to determine the size of the hash table.

EsempioExample

// cliext_hash_map_bucket_count.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1 = gcnew Myhash_map;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }
[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

hash_map::clear (STL/CLR)hash_map::clear (STL/CLR)

Rimuove tutti gli elementi.Removes all elements.

SintassiSyntax

void clear();

NoteRemarks

La funzione membro chiama in modo efficace hash_map:: Erase (STL/CLR) ( hash_map:: Begin (STL/CLR) (), hash_map:: end (STL/CLR) ()).The member function effectively calls hash_map::erase (STL/CLR)( hash_map::begin (STL/CLR)(), hash_map::end (STL/CLR)()). Utilizzarla per assicurarsi che la sequenza controllata è vuota.You use it to ensure that the controlled sequence is empty.

EsempioExample

// cliext_hash_map_clear.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));

    // display contents " [a 1] [b 2]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }
[a 1] [b 2] [c 3]
size() = 0
[a 1] [b 2]
size() = 0

hash_map::const_iterator (STL/CLR)hash_map::const_iterator (STL/CLR)

Tipo di un iteratore costante per la sequenza controllata.The type of a constant iterator for the controlled sequence.

SintassiSyntax

typedef T2 const_iterator;

NoteRemarks

Il tipo descrive un oggetto di tipo non specificato T2 che può essere usato come iteratore costante bidirezionale per la sequenza controllata.The type describes an object of unspecified type T2 that can serve as a constant bidirectional iterator for the controlled sequence.

EsempioExample

// cliext_hash_map_const_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_map::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("[{0} {1}] ", cit->first, cit->second);
    System::Console::WriteLine();
    return (0);
    }
[a 1] [b 2] [c 3]

hash_map::const_reference (STL/CLR)hash_map::const_reference (STL/CLR)

Tipo di un riferimento costante a un elemento.The type of a constant reference to an element.

SintassiSyntax

typedef value_type% const_reference;

NoteRemarks

Il tipo descrive un riferimento costante a un elemento.The type describes a constant reference to an element.

EsempioExample

// cliext_hash_map_const_reference.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_map::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Myhash_map::const_reference cref = *cit;
        System::Console::Write("[{0} {1}] ", cref->first, cref->second);
        }
    System::Console::WriteLine();
    return (0);
    }
[a 1] [b 2] [c 3]

hash_map::const_reverse_iterator (STL/CLR)hash_map::const_reverse_iterator (STL/CLR)

Il tipo di iteratore inverso costante per la sequenza controllata...The type of a constant reverse iterator for the controlled sequence..

SintassiSyntax

typedef T4 const_reverse_iterator;

NoteRemarks

Il tipo descrive un oggetto di tipo non specificato T4 che può essere usato come iteratore inverso costante per la sequenza controllata.The type describes an object of unspecified type T4 that can serve as a constant reverse iterator for the controlled sequence.

EsempioExample

// cliext_hash_map_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" reversed
    Myhash_map::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("[{0} {1}] ", crit->first, crit->second);
    System::Console::WriteLine();
    return (0);
    }
[c 3] [b 2] [a 1]

hash_map::count (STL/CLR)hash_map::count (STL/CLR)

Trova il numero di elementi corrispondenti a una chiave specificata.Finds the number of elements matching a specified key.

SintassiSyntax

size_type count(key_type key);

ParametriParameters

keykey
Valore della chiave da cercare.Key value to search for.

NoteRemarks

La funzione membro restituisce il numero di elementi nella sequenza controllata che hanno un ordinamento equivalente con chiave.The member function returns the number of elements in the controlled sequence that have equivalent ordering with key. Utilizzarla per determinare il numero di elementi attualmente presenti nella sequenza controllata che corrispondono a una chiave specificata.You use it to determine the number of elements currently in the controlled sequence that match a specified key.

EsempioExample

// cliext_hash_map_count.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("count(L'A') = {0}", c1.count(L'A'));
    System::Console::WriteLine("count(L'b') = {0}", c1.count(L'b'));
    System::Console::WriteLine("count(L'C') = {0}", c1.count(L'C'));
    return (0);
    }
[a 1] [b 2] [c 3]
count(L'A') = 0
count(L'b') = 1
count(L'C') = 0

hash_map:: difference_type (STL/CLR)hash_map::difference_type (STL/CLR)

I tipi di una distanza signed tra due elementi.The types of a signed distance between two elements.

SintassiSyntax

typedef int difference_type;

NoteRemarks

Il tipo descrive un conteggio di elementi potenzialmente negativo.The type describes a possibly negative element count.

EsempioExample

// cliext_hash_map_difference_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // compute positive difference
    Myhash_map::difference_type diff = 0;
    for (Myhash_map::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (Myhash_map::iterator it = c1.end(); it != c1.begin(); --it)
        --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }
[a 1] [b 2] [c 3]
end()-begin() = 3
begin()-end() = -3

hash_map:: Empty (STL/CLR)hash_map::empty (STL/CLR)

Verifica se sono presenti o meno degli elementi.Tests whether no elements are present.

SintassiSyntax

bool empty();

NoteRemarks

La funzione membro restituisce true per una sequenza controllata vuota.The member function returns true for an empty controlled sequence. È equivalente a hash_map:: Size (STL/CLR)() == 0.It is equivalent to hash_map::size (STL/CLR)() == 0. Usarlo per verificare se l'oggetto hash_map è vuoto.You use it to test whether the hash_map is empty.

EsempioExample

// cliext_hash_map_empty.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }
[a 1] [b 2] [c 3]
size() = 3
empty() = False
size() = 0
empty() = True

hash_map::end (STL/CLR)hash_map::end (STL/CLR)

Designa la fine della sequenza controllata.Designates the end of the controlled sequence.

SintassiSyntax

iterator end();

NoteRemarks

La funzione membro restituisce un iteratore bidirezionale che punta appena oltre la fine della sequenza controllata.The member function returns a bidirectional iterator that points just beyond the end of the controlled sequence. Usarlo per ottenere un iteratore che designa la fine della sequenza controllata. l relativo stato cambia se la lunghezza della sequenza controllata cambia.You use it to obtain an iterator that designates the end of the controlled sequence; its status doesn not change if the length of the controlled sequence changes.

EsempioExample

// cliext_hash_map_end.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect last two items
    Myhash_map::iterator it = c1.end();
    --it;
    --it;
    System::Console::WriteLine("*-- --end() = [{0} {1}]",
        it->first, it->second);
    ++it;
    System::Console::WriteLine("*--end() = [{0} {1}]",
        it->first, it->second);
    return (0);
    }
[a 1] [b 2] [c 3]
*-- --end() = [b 2]
*--end() = [c 3]

hash_map::equal_range (STL/CLR)hash_map::equal_range (STL/CLR)

Trova un intervallo che corrisponde a una chiave specificata.Finds range that matches a specified key.

SintassiSyntax

cliext::pair<iterator, iterator> equal_range(key_type key);

ParametriParameters

keykey
Valore della chiave da cercare.Key value to search for.

NoteRemarks

La funzione membro restituisce una coppia di iteratori cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key)).The member function returns a pair of iterators cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key)). Utilizzarla per determinare l'intervallo di elementi attualmente presenti nella sequenza controllata che corrispondono a una chiave specificata.You use it to determine the range of elements currently in the controlled sequence that match a specified key.

EsempioExample

// cliext_hash_map_equal_range.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
typedef Myhash_map::pair_iter_iter Pairii;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // display results of failed search
    Pairii pair1 = c1.equal_range(L'x');
    System::Console::WriteLine("equal_range(L'x') empty = {0}",
        pair1.first == pair1.second);

    // display results of successful search
    pair1 = c1.equal_range(L'b');
    for (; pair1.first != pair1.second; ++pair1.first)
        System::Console::Write("[{0} {1}] ",
            pair1.first->first, pair1.first->second);
    System::Console::WriteLine();
    return (0);
    }
[a 1] [b 2] [c 3]
equal_range(L'x') empty = True
[b 2]

hash_map::erase (STL/CLR)hash_map::erase (STL/CLR)

Rimuove gli elementi in corrispondenza delle posizioni specificate.Removes elements at specified positions.

SintassiSyntax

iterator erase(iterator where);
iterator erase(iterator first, iterator last);
bool erase(key_type key)

ParametriParameters

firstfirst
Inizio dell'intervallo da cancellare.Beginning of range to erase.

keykey
Valore della chiave da cancellare.Key value to erase.

lastlast
Fine dell'intervallo da cancellare.End of range to erase.

wherewhere
Elemento da cancellare.Element to erase.

NoteRemarks

La prima funzione membro rimuove l'elemento della sequenza controllata a cui punta in cuie restituisce un iteratore che designa il primo elemento rimanente oltre l'elemento rimosso, o hash_map:: end (STL / Common Language Runtime) () se tale elemento non esiste.The first member function removes the element of the controlled sequence pointed to by where, and returns an iterator that designates the first element remaining beyond the element removed, or hash_map::end (STL/CLR)() if no such element exists. Usarlo per rimuovere un singolo elemento.You use it to remove a single element.

La seconda funzione membro rimuove gli elementi della sequenza controllata nell'intervallo [first, last) e restituisce un iteratore che designa il primo elemento rimanente oltre gli elementi rimossi o end() se tale elemento non esista...The second member function removes the elements of the controlled sequence in the range [first, last), and returns an iterator that designates the first element remaining beyond any elements removed, or end() if no such element exists.. Usarlo per rimuovere zero o più elementi adiacenti.You use it to remove zero or more contiguous elements.

La terza funzione membro rimuove qualsiasi elemento della sequenza controllata cui chiave ha ordinamento equivalente a chiavee restituisce un conteggio del numero di elementi rimossi.The third member function removes any element of the controlled sequence whose key has equivalent ordering to key, and returns a count of the number of elements removed. Usarlo per rimuovere e contare tutti gli elementi che corrispondono a una chiave specificata.You use it to remove and count all elements that match a specified key.

La cancellazione di ogni elemento richiede tempo proporzionale al logaritmo del numero di elementi nella sequenza controllata.Each element erasure takes time proportional to the logarithm of the number of elements in the controlled sequence.

EsempioExample

// cliext_hash_map_erase.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    cliext::hash_map<wchar_t, int> c1;
    c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'a', 1));
    c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'b', 2));
    c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (cliext::hash_map<wchar_t, int>::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // erase an element and reinspect
    cliext::hash_map<wchar_t, int>::iterator it =
        c1.erase(c1.begin());
    System::Console::WriteLine("erase(begin()) = [{0} {1}]",
        it->first, it->second);

    // add elements and display " b c d e"
    c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'd', 4));
    c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'e', 5));
    for each (cliext::hash_map<wchar_t, int>::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // erase all but end
    it = c1.end();
    it = c1.erase(c1.begin(), --it);
    System::Console::WriteLine("erase(begin(), end()-1) = [{0} {1}]",
        it->first, it->second);
    System::Console::WriteLine("size() = {0}", c1.size());

    // erase end
    System::Console::WriteLine("erase(L'x') = {0}", c1.erase(L'x'));
    System::Console::WriteLine("erase(L'e') = {0}", c1.erase(L'e'));
    return (0);
    }
[a 1] [b 2] [c 3]
erase(begin()) = [b 2]
[b 2] [c 3] [d 4] [e 5]
erase(begin(), end()-1) = [e 5]
size() = 1
erase(L'x') = 0
erase(L'e') = 1

hash_map:: Find (STL/CLR)hash_map::find (STL/CLR)

Trova un elemento che corrisponde a una chiave specificata.Finds an element that matches a specified key.

SintassiSyntax

iterator find(key_type key);

ParametriParameters

keykey
Valore della chiave da cercare.Key value to search for.

NoteRemarks

Se almeno un elemento nella sequenza controllata ha ordinamento equivalente a key, la funzione membro restituisce un iteratore che designa una di tali elementi; in caso contrario, restituisce (STL/CLR)hash_map::end ().If at least one element in the controlled sequence has equivalent ordering with key, the member function returns an iterator designating one of those elements; otherwise it returns hash_map::end (STL/CLR)(). Usarlo per individuare un elemento attualmente nella sequenza controllata che corrisponde a una chiave specificata.You use it to locate an element currently in the controlled sequence that matches a specified key.

EsempioExample

// cliext_hash_map_find.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("find {0} = {1}",
        L'A', c1.find(L'A') != c1.end());

    Myhash_map::iterator it = c1.find(L'b');
    System::Console::WriteLine("find {0} = [{1} {2}]",
        L'b', it->first, it->second);

    System::Console::WriteLine("find {0} = {1}",
        L'C', c1.find(L'C') != c1.end());
    return (0);
    }
[a 1] [b 2] [c 3]
find A = False
find b = [b 2]
find C = False

hash_map::generic_container (STL/CLR)hash_map::generic_container (STL/CLR)

Il tipo dell'interfaccia generica per il contenitore.The type of the generic interface for the container.

SintassiSyntax

typedef Microsoft::VisualC::StlClr::
    IHash<GKey, GValue>
    generic_container;

NoteRemarks

Il tipo descrive l'interfaccia generica per questa classe di contenitori di modelli.The type describes the generic interface for this template container class.

EsempioExample

// cliext_hash_map_generic_container.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_map::generic_container^ gc1 = %c1;
    for each (Myhash_map::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(Myhash_map::make_value(L'd', 4));
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // modify original and display generic
    c1.insert(Myhash_map::make_value(L'e', 5));
    for each (Myhash_map::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3] [d 4]
[a 1] [b 2] [c 3] [d 4] [e 5]

hash_map::generic_iterator (STL/CLR)hash_map::generic_iterator (STL/CLR)

Tipo di iteratore per l'uso con l'interfaccia generica per il contenitore.The type of an iterator for use with the generic interface for the container.

SintassiSyntax

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerBidirectionalIterator<generic_value>
    generic_iterator;

NoteRemarks

Il tipo descrive un iteratore generico che può essere utilizzato con l'interfaccia generica per questa classe di contenitori di modelli.The type describes a generic iterator that can be used with the generic interface for this template container class.

EsempioExample

// cliext_hash_map_generic_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_map::generic_container^ gc1 = %c1;
    for each (Myhash_map::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_map::generic_iterator gcit = gc1->begin();
    Myhash_map::generic_value gcval = *gcit;
    System::Console::Write("[{0} {1}] ", gcval->first, gcval->second);
    System::Console::WriteLine();
    return (0);
    }
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1]

hash_map::generic_reverse_iterator (STL/CLR)hash_map::generic_reverse_iterator (STL/CLR)

Il tipo di un iteratore inverso per l'uso con l'interfaccia generica per il contenitore.The type of a reverse iterator for use with the generic interface for the container.

SintassiSyntax

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value>
    generic_reverse_iterator;

NoteRemarks

Il tipo descrive un iteratore inverso generico che può essere utilizzato con l'interfaccia generica per questa classe di contenitori di modelli.The type describes a generic reverse iterator that can be used with the generic interface for this template container class.

EsempioExample

// cliext_hash_map_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_map::generic_container^ gc1 = %c1;
    for each (Myhash_map::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_map::generic_reverse_iterator gcit = gc1->rbegin();
    Myhash_map::generic_value gcval = *gcit;
    System::Console::WriteLine("[{0} {1}] ", gcval->first, gcval->second);
    return (0);
    }
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[c 3]

hash_map::generic_value (STL/CLR)hash_map::generic_value (STL/CLR)

Il tipo di elemento per l'uso con l'interfaccia generica per il contenitore.The type of an element for use with the generic interface for the container.

SintassiSyntax

typedef GValue generic_value;

NoteRemarks

Il tipo descrive un oggetto di tipo GValue che descrive il valore dell'elemento archiviato per l'uso con l'interfaccia generica per questa classe di contenitori di modelli.The type describes an object of type GValue that describes the stored element value for use with the generic interface for this template container class.

EsempioExample

// cliext_hash_map_generic_value.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_map::generic_container^ gc1 = %c1;
    for each (Myhash_map::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_map::generic_iterator gcit = gc1->begin();
    Myhash_map::generic_value gcval = *gcit;
    System::Console::WriteLine("[{0} {1}] ", gcval->first, gcval->second);
    return (0);
    }
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1]

hash_map::hash_delegate (STL/CLR)hash_map::hash_delegate (STL/CLR)

Trova un elemento che corrisponde a una chiave specificata.Finds an element that matches a specified key.

SintassiSyntax

hasher^ hash_delegate();

NoteRemarks

La funzione membro restituisce il delegato utilizzato per convertire un valore di chiave in un intero.The member function returns the delegate used to convert a key value to an integer. Usarlo per eseguire l'hashing di una chiave.You use it to hash a key.

EsempioExample

// cliext_hash_map_hash_delegate.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::hasher^ myhash = c1.hash_delegate();

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }
hash(L'a') = 1616896120
hash(L'b') = 570892832

hash_map::hash_map (STL/CLR)hash_map::hash_map (STL/CLR)

Costruisce un oggetto contenitore.Constructs a container object.

SintassiSyntax

hash_map();
explicit hash_map(key_compare^ pred);
hash_map(key_compare^ pred, hasher^ hashfn);
hash_map(hash_map<Key, Mapped>% right);
hash_map(hash_map<Key, Mapped>^ right);
template<typename InIter>
    hash_maphash_map(InIter first, InIter last);
template<typename InIter>
    hash_map(InIter first, InIter last,
        key_compare^ pred);
template<typename InIter>
    hash_map(InIter first, InIter last,
        key_compare^ pred, hasher^ hashfn);
hash_map(System::Collections::Generic::IEnumerable<GValue>^ right);
hash_map(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred);
hash_map(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred, hasher^ hashfn);

ParametriParameters

firstfirst
Inizio dell'intervallo da inserire.Beginning of range to insert.

hashfnhashfn
Funzione per le chiavi di mapping a bucket di hash.Hash function for mapping keys to buckets.

lastlast
Fine dell'intervallo da inserire.End of range to insert.

predpred
Ordinamento di predicato per la sequenza controllata.Ordering predicate for the controlled sequence.

rightright
Oggetto o un intervallo da inserire.Object or range to insert.

NoteRemarks

Il costruttore:The constructor:

hash_map();

Inizializza la sequenza controllata con alcun elemento, con il predicato dell'ordinamento predefinito key_compare()e con la funzione hash predefinita.initializes the controlled sequence with no elements, with the default ordering predicate key_compare(), and with the default hash function. Usarlo per specificare una sequenza controllata iniziale vuota, con il funzione di predicato e hash dell'ordinamento predefinito.You use it to specify an empty initial controlled sequence, with the default ordering predicate and hash function.

Il costruttore:The constructor:

explicit hash_map(key_compare^ pred);

Inizializza la sequenza controllata con alcun elemento, con il predicato di ordinamento prede con la funzione hash predefinita.initializes the controlled sequence with no elements, with the ordering predicate pred, and with the default hash function. Usarlo per specificare una sequenza controllata iniziale vuota, con il predicato di ordinamento specificato e la funzione hash predefinita.You use it to specify an empty initial controlled sequence, with the specified ordering predicate and the default hash function.

Il costruttore:The constructor:

hash_map(key_compare^ pred, hasher^ hashfn);

Inizializza la sequenza controllata con alcun elemento, con il predicato di ordinamento prede con la funzione hash hashfn.initializes the controlled sequence with no elements, with the ordering predicate pred, and with the hash function hashfn. Usarlo per specificare una sequenza controllata iniziale vuota, con funzione di predicato e hash ordinamento specificata.You use it to specify an empty initial controlled sequence, with the specified ordering predicate and hash function.

Il costruttore:The constructor:

hash_map(hash_map<Key, Mapped>% right);

Inizializza la sequenza controllata con la sequenza [right.begin(), right.end()), con il predicato dell'ordinamento predefinito e con la funzione hash predefinita.initializes the controlled sequence with the sequence [right.begin(), right.end()), with the default ordering predicate, and with the default hash function. È utilizzata per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dall'oggetto hash_map a destra, con il predicato di ordinamento predefinita e funzione hash.You use it to specify an initial controlled sequence that is a copy of the sequence controlled by the hash_map object right, with the default ordering predicate and hash function.

Il costruttore:The constructor:

hash_map(hash_map<Key, Mapped>^ right);

Inizializza la sequenza controllata con la sequenza [right->begin(), right->end()), con il predicato dell'ordinamento predefinito e con la funzione hash predefinita.initializes the controlled sequence with the sequence [right->begin(), right->end()), with the default ordering predicate, and with the default hash function. È utilizzata per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dall'oggetto hash_map a destra, con il predicato di ordinamento predefinita e funzione hash.You use it to specify an initial controlled sequence that is a copy of the sequence controlled by the hash_map object right, with the default ordering predicate and hash function.

Il costruttore:The constructor:

template<typename InIter> hash_map(InIter first, InIter last);

Inizializza la sequenza controllata con la sequenza [first, last), con il predicato dell'ordinamento predefinito e con la funzione hash predefinita.initializes the controlled sequence with the sequence [first, last), with the default ordering predicate, and with the default hash function. Usarlo per creare la sequenza controllata una copia di un'altra sequenza, con il funzione di predicato e hash dell'ordinamento predefinito.You use it to make the controlled sequence a copy of another sequence, with the default ordering predicate and hash function.

Il costruttore:The constructor:

template<typename InIter> hash_map(InIter first, InIter last, key_compare^ pred);

Inizializza la sequenza controllata con la sequenza [first, last), con il predicato di ordinamento prede con la funzione hash predefinita.initializes the controlled sequence with the sequence [first, last), with the ordering predicate pred, and with the default hash function. Usarlo per creare una copia di un'altra sequenza, con il predicato di ordinamento specificato e la funzione hash predefinita la sequenza controllata.You use it to make the controlled sequence a copy of another sequence, with the specified ordering predicate and the default hash function.

Il costruttore:The constructor:

template<typename InIter> hash_map(InIter first, InIter last, key_compare^ pred, hasher^ hashfn);

Inizializza la sequenza controllata con la sequenza [first, last), con il predicato di ordinamento prede con la funzione hash hashfn.initializes the controlled sequence with the sequence [first, last), with the ordering predicate pred, and with the hash function hashfn. Usarlo per creare una copia di un'altra sequenza, con funzione di predicato e hash ordinamento specificata nella sequenza controllata.You use it to make the controlled sequence a copy of another sequence, with the specified ordering predicate and hash function.

Il costruttore:The constructor:

hash_map(System::Collections::Generic::IEnumerable<Key>^ right);

Inizializza la sequenza controllata con la sequenza definita dall'enumeratore a destra, con il predicato dell'ordinamento predefinito e con la funzione hash predefinita.initializes the controlled sequence with the sequence designated by the enumerator right, with the default ordering predicate, and with the default hash function. Usarlo per creare una copia di un'altra sequenza descritta da un enumeratore con l'impostazione predefinita funzioni di predicato e hash di ordinamento nella sequenza controllata.You use it to make the controlled sequence a copy of another sequence described by an enumerator, with the default ordering predicate and hash function.

Il costruttore:The constructor:

hash_map(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred);

Inizializza la sequenza controllata con la sequenza definita dall'enumeratore a destra, con il predicato di ordinamento prede con la funzione hash predefinita.initializes the controlled sequence with the sequence designated by the enumerator right, with the ordering predicate pred, and with the default hash function. Usarlo per creare una copia di un'altra sequenza descritta da un enumeratore, con la funzione di hash predefinito e predicato di ordinamento specificata nella sequenza controllata.You use it to make the controlled sequence a copy of another sequence described by an enumerator, with the specified ordering predicate and default hash function.

Il costruttore:The constructor:

hash_map(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred, hasher^ hashfn);

Inizializza la sequenza controllata con la sequenza definita dall'enumeratore a destra, con il predicato di ordinamento prede con la funzione hash hashfn.initializes the controlled sequence with the sequence designated by the enumerator right, with the ordering predicate pred, and with the hash function hashfn. Usarlo per creare una copia di un'altra sequenza descritta da un enumeratore, con funzione di predicato e hash ordinamento specificato nella sequenza controllata.You use it to make the controlled sequence a copy of another sequence described by an enumerator, with the specified ordering predicate and hash function.

EsempioExample

// cliext_hash_map_construct.cpp
// compile with: /clr
#include <cliext/hash_map>

int myfun(wchar_t key)
    { // hash a key
    return (key ^ 0xdeadbeef);
    }

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
// construct an empty container
    Myhash_map c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an ordering rule
    Myhash_map c2 = cliext::greater_equal<wchar_t>();
    System::Console::WriteLine("size() = {0}", c2.size());

    c2.insert(c1.begin(), c1.end());
    for each (Myhash_map::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an ordering rule and hash function
    Myhash_map c2h(cliext::greater_equal<wchar_t>(),
        gcnew Myhash_map::hasher(&myfun));
    System::Console::WriteLine("size() = {0}", c2h.size());

    c2h.insert(c1.begin(), c1.end());
    for each (Myhash_map::value_type elem in c2h)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an iterator range
    Myhash_map c3(c1.begin(), c1.end());
    for each (Myhash_map::value_type elem in c3)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule
    Myhash_map c4(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>());
    for each (Myhash_map::value_type elem in c4)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule and hash function
    Myhash_map c4h(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>(),
        gcnew Myhash_map::hasher(&myfun));
    for each (Myhash_map::value_type elem in c4h)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an enumeration
    Myhash_map c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Myhash_map::value_type>^)%c3);
    for each (Myhash_map::value_type elem in c5)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule
    Myhash_map c6(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Myhash_map::value_type>^)%c3,
                cliext::greater_equal<wchar_t>());
    for each (Myhash_map::value_type elem in c6)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule and hash function
    Myhash_map c6h(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Myhash_map::value_type>^)%c3,
                cliext::greater_equal<wchar_t>(),
                gcnew Myhash_map::hasher(&myfun));
    for each (Myhash_map::value_type elem in c6h)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct by copying another container
    Myhash_map c7(c4);
    for each (Myhash_map::value_type elem in c7)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct by copying a container handle
    Myhash_map c8(%c3);
    for each (Myhash_map::value_type elem in c8)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }
size() = 0
[a 1] [b 2] [c 3]
size() = 0
[a 1] [b 2] [c 3]
size() = 0
[c 3] [b 2] [a 1]

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[c 3] [b 2] [a 1]

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[c 3] [b 2] [a 1]

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]

hash_map::hasher (STL/CLR)hash_map::hasher (STL/CLR)

Il delegato hash per una chiave.The hashing delegate for a key.

SintassiSyntax

Microsoft::VisualC::StlClr::UnaryDelegate<GKey, int>
    hasher;

NoteRemarks

Il tipo descrive un delegato che converte un valore di chiave in un intero.The type describes a delegate that converts a key value to an integer.

EsempioExample

// cliext_hash_map_hasher.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::hasher^ myhash = c1.hash_delegate();

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }
hash(L'a') = 1616896120
hash(L'b') = 570892832

hash_map::insert (STL/CLR)hash_map::insert (STL/CLR)

Aggiunge elementi.Adds elements.

SintassiSyntax

cliext::pair<iterator, bool> insert(value_type val);
iterator insert(iterator where, value_type val);
template<typename InIter>
    void insert(InIter first, InIter last);
void insert(System::Collections::Generic::IEnumerable<value_type>^ right);

ParametriParameters

firstfirst
Inizio dell'intervallo da inserire.Beginning of range to insert.

lastlast
Fine dell'intervallo da inserire.End of range to insert.

rightright
Enumerazione da inserire.Enumeration to insert.

valval
Valore della chiave da inserire.Key value to insert.

wherewhere
Posizione in cui nel contenitore da inserire (solo hint).Where in container to insert (hint only).

NoteRemarks

Ognuna delle funzioni membro inserisce una sequenza specificata dagli operandi rimanenti.Each of the member functions inserts a sequence specified by the remaining operands.

La prima funzione membro tenta di inserire un elemento con valore vale restituisce una coppia di valori X.The first member function endeavors to insert an element with value val, and returns a pair of values X. Se X.second è true, X.first designa l'elemento appena inserito; in caso contrario X.first definisce un elemento con l'equivalente di ordinamento che già esiste e viene inserito alcun nuovo elemento.If X.second is true, X.first designates the newly inserted element; otherwise X.first designates an element with equivalent ordering that already exists and no new element is inserted. Usarlo per inserire un singolo elemento.You use it to insert a single element.

La seconda funzione membro inserisce un elemento con valore val, usando in cui come un suggerimento (per migliorare le prestazioni) e restituisce un iteratore che designa l'elemento appena inserito.The second member function inserts an element with value val, using where as a hint (to improve performance), and returns an iterator that designates the newly inserted element. Usarlo per inserire un singolo elemento che potrebbe essere adiacente a un elemento che si conosce.You use it to insert a single element which might be adjacent to an element you know.

La terza funzione membro inserisce la sequenza [first, last).The third member function inserts the sequence [first, last). Usarlo per l'inserimento di zero o più elementi copiati da un'altra sequenza.You use it to insert zero or more elements copied from another sequence.

La quarta funzione membro inserisce la sequenza designata per il a destra.The fourth member function inserts the sequence designated by the right. Usarlo per inserire una sequenza descritta da un enumeratore.You use it to insert a sequence described by an enumerator.

Ogni inserimento di elementi richiede tempo proporzionale al logaritmo del numero di elementi nella sequenza controllata.Each element insertion takes time proportional to the logarithm of the number of elements in the controlled sequence. Inserimento può avvenire in tempo costante ammortizzato, tuttavia, dato un suggerimento che definisce un elemento adiacente al punto di inserimento.Insertion can occur in amortized constant time, however, given a hint that designates an element adjacent to the insertion point.

EsempioExample

// cliext_hash_map_insert.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
typedef Myhash_map::pair_iter_bool Pairib;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert a single value, unique and duplicate
    Pairib pair1 =
        c1.insert(Myhash_map::make_value(L'x', 24));
    System::Console::WriteLine("insert([L'x' 24]) = [{0} {1}] {2}",
        pair1.first->first, pair1.first->second, pair1.second);

    pair1 = c1.insert(Myhash_map::make_value(L'b', 2));
    System::Console::WriteLine("insert([L'b' 2]) = [{0} {1}] {2}",
        pair1.first->first, pair1.first->second, pair1.second);

    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert a single value with hint
    Myhash_map::iterator it =
        c1.insert(c1.begin(), Myhash_map::make_value(L'y', 25));
    System::Console::WriteLine("insert(begin(), [L'y' 25]) = [{0} {1}]",
        it->first, it->second);
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert an iterator range
    Myhash_map c2;
    it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (Myhash_map::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert an enumeration
    Myhash_map c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::
            IEnumerable<Myhash_map::value_type>^)%c1);
    for each (Myhash_map::value_type elem in c3)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }
[a 1] [b 2] [c 3]
insert([L'x' 24]) = [x 24] True
insert([L'b' 2]) = [b 2] False
[a 1] [b 2] [c 3] [x 24]
insert(begin(), [L'y' 25]) = [y 25]
[a 1] [b 2] [c 3] [x 24] [y 25]
[a 1] [b 2] [c 3] [x 24]
[a 1] [b 2] [c 3] [x 24] [y 25]

hash_map::iterator (STL/CLR)hash_map::iterator (STL/CLR)

Tipo di un iteratore per la sequenza controllata.The type of an iterator for the controlled sequence.

SintassiSyntax

typedef T1 iterator;

NoteRemarks

Il tipo descrive un oggetto di tipo non specificato T1 che può essere usato come iteratore bidirezionale per la sequenza controllata.The type describes an object of unspecified type T1 that can serve as a bidirectional iterator for the controlled sequence.

EsempioExample

// cliext_hash_map_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_map::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("[{0} {1}] ", it->first, it->second);
    System::Console::WriteLine();
    return (0);
    }
[a 1] [b 2] [c 3]

hash_map::key_comp (STL/CLR)hash_map::key_comp (STL/CLR)

Copia il delegato di ordinamento per due chiavi.Copies the ordering delegate for two keys.

SintassiSyntax

key_compare^key_comp();

NoteRemarks

La funzione membro restituisce il delegato di ordinamento usato per ordinare la sequenza controllata.The member function returns the ordering delegate used to order the controlled sequence. È utilizzato per confrontare due chiavi.You use it to compare two keys.

EsempioExample

// cliext_hash_map_key_comp.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Myhash_map c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }
compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

hash_map::key_compare (STL/CLR)hash_map::key_compare (STL/CLR)

Delegato di ordinamento per due chiavi.The ordering delegate for two keys.

SintassiSyntax

Microsoft::VisualC::StlClr::BinaryDelegate<GKey, GKey, bool>
    key_compare;

NoteRemarks

Il tipo è un sinonimo per il delegato che determina l'ordine dei relativi argomenti chiave.The type is a synonym for the delegate that determines the ordering of its key arguments.

EsempioExample

// cliext_hash_map_key_compare.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Myhash_map c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }
compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

hash_map::key_type (STL/CLR)hash_map::key_type (STL/CLR)

Tipo di una chiave di ordinamento.The type of an ordering key.

SintassiSyntax

typedef Key key_type;

NoteRemarks

Il tipo è un sinonimo del parametro di modello chiave.The type is a synonym for the template parameter Key.

EsempioExample

// cliext_hash_map_key_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using key_type
    for (Myhash_map::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Myhash_map::key_type val = it->first;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }
a b c

hash_map::load_factor (STL/CLR)hash_map::load_factor (STL/CLR)

Conta il numero medio di elementi per bucket.Counts the average elements per bucket.

SintassiSyntax

float load_factor();

NoteRemarks

La funzione membro restituisce (float) hash_map:: Size (STL/CLR) () / hash_map::bucket_count (STL/CLR)().The member function returns (float)hash_map::size (STL/CLR)() / hash_map::bucket_count (STL/CLR)(). Utilizzarla per determinare la dimensione del bucket medio.You use it to determine the average bucket size.

EsempioExample

// cliext_hash_map_load_factor.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1 = gcnew Myhash_map;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }
[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

hash_map::lower_bound (STL/CLR)hash_map::lower_bound (STL/CLR)

Trova l'inizio dell'intervallo che corrisponde a una chiave specificata.Finds beginning of range that matches a specified key.

SintassiSyntax

iterator lower_bound(key_type key);

ParametriParameters

keykey
Valore della chiave da cercare.Key value to search for.

NoteRemarks

La funzione membro determina che il primo elemento X nella sequenza controllata che genera un hash allo stesso bucket di chiave e ha ordinamento equivalente a chiave.The member function determines the first element X in the controlled sequence that hashes to the same bucket as key and has equivalent ordering to key. Se tale elemento non esiste, restituisce hash_map:: end (STL/CLR)(); in caso contrario, restituisce un iteratore che designa X.If no such element exists, it returns hash_map::end (STL/CLR)(); otherwise it returns an iterator that designates X. Usarlo per individuare l'inizio di una sequenza di elementi attualmente nella sequenza controllata che corrispondono a una chiave specificata.You use it to locate the beginning of a sequence of elements currently in the controlled sequence that match a specified key.

EsempioExample

// cliext_hash_map_lower_bound.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("lower_bound(L'x')==end() = {0}",
        c1.lower_bound(L'x') == c1.end());

    Myhash_map::iterator it = c1.lower_bound(L'a');
    System::Console::WriteLine("*lower_bound(L'a') = [{0} {1}]",
        it->first, it->second);
    it = c1.lower_bound(L'b');
    System::Console::WriteLine("*lower_bound(L'b') = [{0} {1}]",
        it->first, it->second);
    return (0);
    }
[a 1] [b 2] [c 3]
lower_bound(L'x')==end() = True
*lower_bound(L'a') = [a 1]
*lower_bound(L'b') = [b 2]

hash_map::make_value (STL/CLR)hash_map::make_value (STL/CLR)

Costruisce un oggetto valore.Constructs a value object.

SintassiSyntax

static value_type make_value(key_type key, mapped_type mapped);

ParametriParameters

keykey
Valore della chiave da usare.Key value to use.

mappedmapped
Valore mappato per la ricerca.Mapped value to search for.

NoteRemarks

La funzione membro restituisce un value_type oggetto la cui chiave è chiave ed è il cui valore mappato mappato.The member function returns a value_type object whose key is key and whose mapped value is mapped. Usarlo per creare un oggetto può essere utilizzato con diverse altre funzioni membro.You use it to compose an object suitable for use with several other member functions.

EsempioExample

// cliext_hash_map_make_value.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }
[a 1] [b 2] [c 3]

hash_map::mapped_type (STL/CLR)hash_map::mapped_type (STL/CLR)

Tipo di un valore mappato associato a ogni chiave.The type of a mapped value associated with each key.

SintassiSyntax

typedef Mapped mapped_type;

NoteRemarks

Il tipo è un sinonimo del parametro di modello Mapped.The type is a synonym for the template parameter Mapped.

EsempioExample

// cliext_hash_map_mapped_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using mapped_type
    for (Myhash_map::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in mapped_type object
        Myhash_map::mapped_type val = it->second;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }
1 2 3

hash_map::max_load_factor (STL/CLR)hash_map::max_load_factor (STL/CLR)

Ottiene o imposta il numero massimo di elementi per bucket.Gets or sets the maximum elements per bucket.

SintassiSyntax

float max_load_factor();
void max_load_factor(float new_factor);

ParametriParameters

new_factornew_factor
Nuovo massimo carico fattore da archiviare.New maximum load factor to store.

NoteRemarks

La prima funzione membro restituisce il fattore di carico massimo archiviato corrente.The first member function returns the current stored maximum load factor. Utilizzarla per determinare le dimensioni massime bucket medio.You use it to determine the maximum average bucket size.

La seconda funzione membro sostituisce il fattore di carico massimo archivio con new_factor.The second member function replaces the store maximum load factor with new_factor. Nessun generando automatica si verifica solo l'inserimento di una successiva.No automatic rehashing occurs until a subsequent insert.

EsempioExample

// cliext_hash_map_max_load_factor.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1 = gcnew Myhash_map;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }
[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

hash_map::operator= (STL/CLR)hash_map::operator= (STL/CLR)

Sostituisce la sequenza controllata.Replaces the controlled sequence.

SintassiSyntax

hash_map<Key, Mapped>% operator=(hash_map<Key, Mapped>% right);

ParametriParameters

rightright
Contenitore da copiare.Container to copy.

NoteRemarks

Le copie di operatore membro a destra all'oggetto, quindi restituisce *this.The member operator copies right to the object, then returns *this. Usarlo per sostituire la sequenza controllata con una copia della sequenza controllata nel a destra.You use it to replace the controlled sequence with a copy of the controlled sequence in right.

EsempioExample

// cliext_hash_map_operator_as.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Myhash_map c2;
    c2 = c1;
// display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]

hash_map::operator(STL/CLR)hash_map::operator(STL/CLR)

Esegue il mapping di una chiave per il relativo valore mappato associato.Maps a key to its associated mapped value.

SintassiSyntax

mapped_type operator[](key_type key);

ParametriParameters

keykey
Valore della chiave da cercare.Key value to search for.

NoteRemarks

Le funzioni membro per trovare un elemento con ordinamento equivalente a fallimentari chiave.The member functions endeavors to find an element with equivalent ordering to key. Se ne trova uno, restituisce il valore mappato associato; in caso contrario, inserisce value_type(key, mapped_type()) e restituisce l'oggetto associato (impostazione predefinita) eseguito il mapping di valore.If it finds one, it returns the associated mapped value; otherwise, it inserts value_type(key, mapped_type()) and returns the associated (default) mapped value. Usarlo per cercare un valore mappato dato la chiave associata, o per garantire che una voce esistente per la chiave, se ne viene individuato nessuno.You use it to look up a mapped value given its associated key, or to ensure that an entry exists for the key if none is found.

EsempioExample

// cliext_hash_map_operator_sub.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("c1[{0}] = {1}",
        L'A', c1[L'A']);
    System::Console::WriteLine("c1[{0}] = {1}",
        L'b', c1[L'b']);

    // redisplay altered contents
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // alter mapped values and redisplay
    c1[L'A'] = 10;
    c1[L'c'] = 13;
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }
[a 1] [b 2] [c 3]
c1[A] = 0
c1[b] = 2
[a 1] [A 0] [b 2] [c 3]
[a 1] [A 10] [b 2] [c 13]

hash_map::rbegin (STL/CLR)hash_map::rbegin (STL/CLR)

Indica l'inizio della sequenza controllata inversa.Designates the beginning of the reversed controlled sequence.

SintassiSyntax

reverse_iterator rbegin();

NoteRemarks

La funzione membro restituisce un iteratore inverso che definisce l'ultimo elemento della sequenza controllata o appena oltre l'inizio di una sequenza vuota.The member function returns a reverse iterator that designates the last element of the controlled sequence, or just beyond the beginning of an empty sequence. Di conseguenza, indica il beginning della sequenza inversa.Hence, it designates the beginning of the reverse sequence. Usarlo per ottenere un iteratore che designa il current inizio della sequenza controllata considerata in ordine inverso, ma il cui stato può modificarsi se la lunghezza della sequenza controllata cambia.You use it to obtain an iterator that designates the current beginning of the controlled sequence seen in reverse order, but its status can change if the length of the controlled sequence changes.

EsempioExample

// cliext_hash_map_rbegin.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Myhash_map::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = [{0} {1}]",
        rit->first, rit->second);
    ++rit;
    System::Console::WriteLine("*++rbegin() = [{0} {1}]",
        rit->first, rit->second);
    return (0);
    }
[a 1] [b 2] [c 3]
*rbegin() = [c 3]
*++rbegin() = [b 2]

hash_map::reference (STL/CLR)hash_map::reference (STL/CLR)

Tipo di un riferimento a un elemento.The type of a reference to an element.

SintassiSyntax

typedef value_type% reference;

NoteRemarks

Il tipo descrive un riferimento a un elemento.The type describes a reference to an element.

EsempioExample

// cliext_hash_map_reference.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_map::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Myhash_map::reference ref = *it;
        System::Console::Write("[{0} {1}] ", ref->first, ref->second);
        }
    System::Console::WriteLine();
    return (0);
    }
[a 1] [b 2] [c 3]

hash_map::rehash (STL/CLR)hash_map::rehash (STL/CLR)

Ricompila la tabella hash.Rebuilds the hash table.

SintassiSyntax

void rehash();

NoteRemarks

La funzione membro Ricompila la tabella hash, assicurando hash_map::load_factor (STL/CLR) () <= hash_map::max_load_factor (STL/CLR).The member function rebuilds the hash table, ensuring that hash_map::load_factor (STL/CLR)() <= hash_map::max_load_factor (STL/CLR). In caso contrario, la tabella hash aumenta le dimensioni solo in base alle esigenze dopo un inserimento.Otherwise, the hash table increases in size only as needed after an insertion. (Mai automaticamente riduce le dimensioni.) Usarlo per modificare le dimensioni della tabella hash.(It never automatically decreases in size.) You use it to adjust the size of the hash table.

EsempioExample

// cliext_hash_map_rehash.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1 = gcnew Myhash_map;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }
[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

hash_map::rend (STL/CLR)hash_map::rend (STL/CLR)

Indica la fine della sequenza controllata inversa.Designates the end of the reversed controlled sequence.

SintassiSyntax

reverse_iterator rend();

NoteRemarks

La funzione membro restituisce un iteratore inverso che punta appena oltre l'inizio della sequenza controllata.The member function returns a reverse iterator that points just beyond the beginning of the controlled sequence. Di conseguenza, indica il end della sequenza inversa.Hence, it designates the end of the reverse sequence. Usarlo per ottenere un iteratore che designa il current fine della sequenza controllata considerata in ordine inverso, ma il cui stato può modificarsi se la lunghezza della sequenza controllata cambia.You use it to obtain an iterator that designates the current end of the controlled sequence seen in reverse order, but its status can change if the length of the controlled sequence changes.

EsempioExample

// cliext_hash_map_rend.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Myhash_map::reverse_iterator rit = c1.rend();
    --rit;
    --rit;
    System::Console::WriteLine("*-- --rend() = [{0} {1}]",
        rit->first, rit->second);
    ++rit;
    System::Console::WriteLine("*--rend() = [{0} {1}]",
        rit->first, rit->second);
    return (0);
    }
[a 1] [b 2] [c 3]
*-- --rend() = [b 2]
*--rend() = [a 1]

hash_map::reverse_iterator (STL/CLR)hash_map::reverse_iterator (STL/CLR)

Tipo di un iteratore inverso della sequenza controllata.The type of a reverse iterator for the controlled sequence.

SintassiSyntax

typedef T3 reverse_iterator;

NoteRemarks

Il tipo descrive un oggetto di tipo non specificato T3 che può essere utilizzato come iteratore inverso per la sequenza controllata.The type describes an object of unspecified type T3 that can serve as a reverse iterator for the controlled sequence.

EsempioExample

// cliext_hash_map_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" reversed
    Myhash_map::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("[{0} {1}] ", rit->first, rit->second);
    System::Console::WriteLine();
    return (0);
    }
[c 3] [b 2] [a 1]

hash_map::size (STL/CLR)hash_map::size (STL/CLR)

Conta il numero di elementi.Counts the number of elements.

SintassiSyntax

size_type size();

NoteRemarks

La funzione membro restituisce la lunghezza della sequenza controllata.The member function returns the length of the controlled sequence. Utilizzarla per determinare il numero di elementi attualmente presenti nella sequenza controllata.You use it to determine the number of elements currently in the controlled sequence. Se si è interessati è se la sequenza ha dimensioni diverse da zero, vedere hash_map:: Empty (STL/CLR)().If all you care about is whether the sequence has nonzero size, see hash_map::empty (STL/CLR)().

EsempioExample

// cliext_hash_map_size.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.insert(Myhash_map::make_value(L'd', 4));
    c1.insert(Myhash_map::make_value(L'e', 5));
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }
[a 1] [b 2] [c 3]
size() = 0 after clearing
size() = 2 after adding 2

hash_map::size_type (STL/CLR)hash_map::size_type (STL/CLR)

Il tipo di una distanza signed tra due elementi.The type of a signed distance between two element.

SintassiSyntax

typedef int size_type;

NoteRemarks

Il tipo descrive un conteggio di elementi non negativo.The type describes a non-negative element count.

EsempioExample

// cliext_hash_map_size_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // compute positive difference
    Myhash_map::size_type diff = 0;
    for (Myhash_map::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }
[a 1] [b 2] [c 3]
end()-begin() = 3

hash_map::swap (STL/CLR)hash_map::swap (STL/CLR)

Scambia il contenuto di due contenitori.Swaps the contents of two containers.

SintassiSyntax

void swap(hash_map<Key, Mapped>% right);

ParametriParameters

rightright
Contenitore con cui scambiare il contenuto.Container to swap contents with.

NoteRemarks

La funzione membro Scambia le sequenze controllate tra this e destro.The member function swaps the controlled sequences between this and right. Esegue l'operazione in un tempo costante e non genera alcuna eccezione.It does so in constant time and it throws no exceptions. Usarlo come un modo rapido per scambiare il contenuto di due contenitori.You use it as a quick way to exchange the contents of two containers.

EsempioExample

// cliext_hash_map_swap.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct another container with repetition of values
    Myhash_map c2;
    c2.insert(Myhash_map::make_value(L'd', 4));
    c2.insert(Myhash_map::make_value(L'e', 5));
    c2.insert(Myhash_map::make_value(L'f', 6));
    for each (Myhash_map::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    for each (Myhash_map::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }
[a 1] [b 2] [c 3]
[d 4] [e 5] [f 6]
[d 4] [e 5] [f 6]
[a 1] [b 2] [c 3]

hash_map::to_array (STL/CLR)hash_map::to_array (STL/CLR)

Copia la sequenza controllata in una nuova matrice.Copies the controlled sequence to a new array.

SintassiSyntax

cli::array<value_type>^ to_array();

NoteRemarks

La funzione membro restituisce una matrice che contiene la sequenza controllata.The member function returns an array containing the controlled sequence. È utilizzato per ottenere una copia della sequenza controllata in forma di matrice.You use it to obtain a copy of the controlled sequence in array form.

EsempioExample

// cliext_hash_map_to_array.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // copy the container and modify it
    cli::array<Myhash_map::value_type>^ a1 = c1.to_array();

    c1.insert(Myhash_map::make_value(L'd', 4));
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (Myhash_map::value_type elem in a1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }
[a 1] [b 2] [c 3] [d 4]
[a 1] [b 2] [c 3]

hash_map::upper_bound (STL/CLR)hash_map::upper_bound (STL/CLR)

Trova fine dell'intervallo che corrisponde a una chiave specificata.Finds end of range that matches a specified key.

SintassiSyntax

iterator upper_bound(key_type key);

ParametriParameters

keykey
Valore della chiave da cercare.Key value to search for.

NoteRemarks

La funzione membro determina che l'ultimo elemento X nella sequenza controllata che genera un hash allo stesso bucket di chiave e ha ordinamento equivalente a chiave.The member function determines the last element X in the controlled sequence that hashes to the same bucket as key and has equivalent ordering to key. Se tale elemento non esiste o se X è l'ultimo elemento nella sequenza controllata, restituisce hash_map:: end (STL/CLR)(); in caso contrario, restituisce un iteratore che designa il primo elemento successivo X.If no such element exists, or if X is the last element in the controlled sequence, it returns hash_map::end (STL/CLR)(); otherwise it returns an iterator that designates the first element beyond X. Usarlo per individuare la fine di una sequenza di elementi attualmente nella sequenza controllata che corrispondono a una chiave specificata.You use it to locate the end of a sequence of elements currently in the controlled sequence that match a specified key.

EsempioExample

// cliext_hash_map_upper_bound.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("upper_bound(L'x')==end() = {0}",
        c1.upper_bound(L'x') == c1.end());

    Myhash_map::iterator it = c1.upper_bound(L'a');
    System::Console::WriteLine("*upper_bound(L'a') = [{0} {1}]",
        it->first, it->second);
    it = c1.upper_bound(L'b');
    System::Console::WriteLine("*upper_bound(L'b') = [{0} {1}]",
        it->first, it->second);
    return (0);
    }
[a 1] [b 2] [c 3]
upper_bound(L'x')==end() = True
*upper_bound(L'a') = [b 2]
*upper_bound(L'b') = [c 3]

hash_map::value_comp (STL/CLR)hash_map::value_comp (STL/CLR)

Copia il delegato di ordinamento per due valori di elemento.Copies the ordering delegate for two element values.

SintassiSyntax

value_compare^ value_comp();

NoteRemarks

La funzione membro restituisce il delegato di ordinamento usato per ordinare la sequenza controllata.The member function returns the ordering delegate used to order the controlled sequence. È utilizzato per confrontare due valori di elemento.You use it to compare two element values.

EsempioExample

// cliext_hash_map_value_comp.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Myhash_map::make_value(L'a', 1),
            Myhash_map::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Myhash_map::make_value(L'a', 1),
            Myhash_map::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Myhash_map::make_value(L'b', 2),
            Myhash_map::make_value(L'a', 1)));
    System::Console::WriteLine();
    return (0);
    }
compare([L'a', 1], [L'a', 1]) = True
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False

hash_map::value_compare (STL/CLR)hash_map::value_compare (STL/CLR)

Delegato di ordinamento per due valori di elemento.The ordering delegate for two element values.

SintassiSyntax

Microsoft::VisualC::StlClr::BinaryDelegate<generic_value, generic_value, bool>
    value_compare;

NoteRemarks

Il tipo è un sinonimo per il delegato che determina l'ordine dei relativi argomenti di valore.The type is a synonym for the delegate that determines the ordering of its value arguments.

EsempioExample

// cliext_hash_map_value_compare.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Myhash_map::make_value(L'a', 1),
            Myhash_map::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Myhash_map::make_value(L'a', 1),
            Myhash_map::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Myhash_map::make_value(L'b', 2),
            Myhash_map::make_value(L'a', 1)));
    System::Console::WriteLine();
    return (0);
    }
compare([L'a', 1], [L'a', 1]) = True
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False

hash_map::value_type (STL/CLR)hash_map::value_type (STL/CLR)

Tipo di un elemento.The type of an element.

SintassiSyntax

typedef generic_value value_type;

NoteRemarks

Il tipo è sinonimo di generic_value.The type is a synonym for generic_value.

EsempioExample

// cliext_hash_map_value_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using value_type
    for (Myhash_map::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Myhash_map::value_type val = *it;
        System::Console::Write("[{0} {1}] ", val->first, val->second);
        }
    System::Console::WriteLine();
    return (0);
    }
[a 1] [b 2] [c 3]