hash_map (STL/CLR)

La classe modello vengono descritti un oggetto e controlli di una sequenza variare lunghezza di elementi che ha accesso bidirezionale.Si utilizza il contenitore hash_map per gestire una sequenza di elementi come tabella hash, ogni voce della tabella archiviante un elenco collegato bidirezionale di nodi e ogni nodo archiviante un elemento.Un elemento è costituito da una chiave, per ordinare la sequenza e di un valore mappato, che passa avanti per disattivare.

Nella descrizione di seguito, GValue sono gli stessi di:

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

Dove:

GKey sono gli stessi di Key a meno che quest'ultimo sia un tipo di riferimento, nel qual caso viene Key^

GMapped sono gli stessi di Mapped a meno che quest'ultimo sia un tipo di riferimento, nel qual caso viene Mapped^

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>
    { ..... };

Parametri

• Chiave
  Tipo del componente chiave di un elemento nella sequenza controllata.

• mappato
  Il tipo del componente aggiuntivo di un elemento nella sequenza selezionata.

Membri

Interfacce

Note

L'oggetto alloca e libera la memoria per la sequenza che controlla come singoli nodi in un elenco collegato bidirezionale.Per velocizzare l'accesso, l'oggetto gestisce inoltre di una matrice di lunghezza dei puntatori nell'elenco (la tabella hash), efficacemente mantenimento dell'elenco di tutto come sequenza di sottoelenchi, o i bucket.Non inserire mai gli elementi in un bucket che mantiene ordinato modifica dei collegamenti tra i nodi, copia il contenuto di un nodo a un altro.Ciò significa che è possibile inserire liberamente e rimuovere elementi senza alterare gli elementi rimanenti.

l'oggetto ordina ogni bucket che controlla chiamando un oggetto delegato archiviato di tipo hash_set::key_compare (STL/CLR).È possibile specificare l'oggetto delegato archiviato quando si crea il hash_set; se non si specifica oggetto delegato, l'impostazione predefinita è il confronto operator<=(key_type, key_type).

Si accede a questo viene archiviato chiamando la funzione membro hash_set::key_comp (STL/CLR)().Tale oggetto delegato deve definire l'ordine equivalente tra le chiavi di tipo hash_set::key_type (STL/CLR).Ciò significa, per due chiavi X e Y:

key_comp()(X, Y) restituisce lo stesso risultato booleano a ogni chiamata.

Se key_comp()(X, Y) && key_comp()(Y, X) è true, quindi X e Y causate da avere ordine equivalente.

Una regola di ordinamento che si comporta come operator<=(key_type, key_type), operator>=(key_type, key_type) o operator==(key_type, key_type) definisce l'ordine eqivalent.

Si noti che il contenitore fornisce solo agli elementi le cui chiavi di ordinamento equivalente e che hash sullo stesso valore Integer) siano adiacenti all'interno di un bucket.A differenza della classe modello hash_multimap (STL/CLR), un oggetto di classe modello hash_map garantisce che le chiavi per tutti gli elementi siano univoche.(Non esistono due chiavi di ordinamento equivalente.)

L'oggetto determina quale bucket deve contenere una chiave specificata di ordine chiamando un oggetto delegato archiviato di tipo hash_set::hasher (STL/CLR).È possibile 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.È possibile specificare l'oggetto delegato archiviato quando si crea il hash_set; se non si specifica oggetto delegato, l'impostazione predefinita è la funzione System::Object::hash_value(key_type).Ciò significa, per qualsiasi chiave X e Y:

hash_delegate()(X) restituisce lo stesso risultato intero a ogni chiamata.

Se X e Y ha ordine equivalente, quindi hash_delegate()(X) deve restituire lo stesso risultato completo di hash_delegate()(Y).

ogni elemento contiene una chiave separata e un valore mappato.La sequenza viene rappresentata in una modalità che consente la ricerca, l'inserimento e la rimozione di un elemento arbitrario attraverso una serie di operazioni che è indipendente dal numero di elementi della sequenza (tempo costante) -- almeno nel migliore dei casi.Inoltre, inserendo un elemento non invalida iteratori e la rimozione di un elemento invalida solo gli iteratori che puntano all'elemento rimosso.

Se i valori con hash non vengono distribuiti uniformemente, tuttavia, un hash la tabella può degenerare.Il limite -- per una funzione hash che restituisce sempre lo stesso valore -- la ricerca, l'inserimento e la rimozione sono proporzionali al numero di elementi della sequenza (tempo lineare).Il contenitore tenta di scegliere una funzione hash ragionevole, una dimensione media del bucket e la dimensione della tabella hash (numero totale dei bucket), ma è possibile eseguire l'override di qualsiasi di queste scelte.Vedere, ad esempio, le funzioni hash_set::max_load_factor (STL/CLR) e hash_set::rehash (STL/CLR).

Un hash_map supporta gli iteratori bidirezionali, è possibile avanzare agli elementi adiacenti fornito un iteratore che definisce un elemento nella sequenza selezionata.Un nodo head speciale corrisponde all'iteratore restituito da hash_map::end (STL/CLR)().È possibile diminuire questo iteratore per ottenere ultimo elemento nella sequenza selezionata, se presente.È possibile incrementare un iteratore di hash_map per ottenere il nodo head quindi confronta uguale a end().Ma non è possibile dereferenziare l'iteratore restituito da end().

Si noti che non è possibile fare riferimento a un elemento del hash_map direttamente in base alla posizione numerica -- ciò richiede un iteratore di accesso casuale.

Un iteratore di hash_map memorizzare l'handle al nodo associato al hash_map, che a sua volta memorizzare l'handle al relativo contenitore associato.È possibile utilizzare gli iteratori solo con i relativi oggetti contenitore associati.Un iteratore di hash_map rimane valido a condizione che il relativo nodo associato al hash_map essere associato a un certo hash_map.inoltre, un iteratore valido è dereferencable -- è possibile utilizzarlo per accedere e modificare il valore dell'elemento che definisce -- a condizione che non sia uguale a end().

Cancellando o la rimozione di un elemento chiama il distruttore per il valore archiviato.Eliminare il contenitore di cancellare tutti gli elementi.Pertanto, un contenitore del tipo di elemento è una classe di riferimento garantisce che nessun elemento terminazione il contenitore.Si noti, tuttavia, che un contenitore di handle fa not elimina i relativi elementi.

Requisiti

intestazione: <cliext/hash_map>

Cliext diSpazio dei nomi:

Vedere anche

Riferimenti

hash_map (STL/CLR)

hash_multiset (STL/CLR)

hash_set (STL/CLR)

map (STL/CLR)

multimap (STL/CLR)

multiset (STL/CLR)

set (STL/CLR)

Altre risorse

Riferimenti alla libreria STL/CLR