hash_multimap (STL/CLR)

Articolo
06/10/2015

La classe modello descrive un oggetto che comandi di una sequenza variare lunghezza di elementi che ha accesso bidirezionale. Utilizzare il contenitore hash_multimap per gestire una sequenza di elementi come tabella hash, ogni voce della tabella archiviando un elenco collegato bidirezionale di nodi e ogni nodo archiviando un elemento. Un elemento è costituito da una chiave, per ordinare la sequenza e un valore mappato, su avanti per il nuovo.

In descrizione di seguito, GValue sono gli stessi di:

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

dove:

GKey sono gli stessi di Key eccetto l'ultimo sia un tipo di riferimento, nel qual caso viene Key^

GMapped sono gli stessi di Mapped eccetto l'ultimo sia un tipo di riferimento, nel qual caso viene Mapped^

template<typename Key,
    typename Mapped>
    ref class hash_multimap
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        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

Definizione del tipo	Descrizione
hash_multimap::const_iterator (STL/CLR)	Il tipo di un iteratore costante della sequenza controllata.
hash_multimap::const_reference (STL/CLR)	Il tipo di un riferimento costante a un elemento.
hash_multimap::const_reverse_iterator (STL/CLR)	Il tipo di iteratore inverso costante per la sequenza selezionata.
hash_multimap::difference_type (STL/CLR)	Il tipo di distanza (eventualmente firmata) tra due elementi.
hash_multimap::generic_container (STL/CLR)	Il tipo dell'interfaccia generica del contenitore.
hash_multimap::generic_iterator (STL/CLR)	Il tipo di iteratore per l'interfaccia generica del contenitore.
hash_multimap::generic_reverse_iterator (STL/CLR)	Il tipo di iteratore inverso per l'interfaccia generica del contenitore.
hash_multimap::generic_value (STL/CLR)	Il tipo di elemento dell'interfaccia generica del contenitore.
hash_multimap::hasher (STL/CLR)	Il delegato di hashing di una chiave.
hash_multimap::iterator (STL/CLR)	Il tipo di un iteratore della sequenza controllata.
hash_multimap::key_compare (STL/CLR)	Il delegato dell'ordine per due chiavi.
hash_multimap::key_type (STL/CLR)	Il tipo di una chiave di ordinamento.
hash_multimap::mapped_type (STL/CLR)	Il tipo del valore mappato associato a ogni chiave.
hash_multimap::reference (STL/CLR)	Il tipo di un riferimento a un elemento.
hash_multimap::reverse_iterator (STL/CLR)	Il tipo di iteratore inverso per la sequenza selezionata.
hash_multimap::size_type (STL/CLR)	Il tipo di distanza (non negativa) a tra due elementi.
hash_multimap::value_compare (STL/CLR)	Il delegato dell'ordine per due valori degli elementi.
hash_multimap::value_type (STL/CLR)	Il tipo di un elemento.

Funzione membro	Descrizione
hash_multimap::begin (STL/CLR)	Definisce l'inizio della sequenza controllata.
hash_multimap::bucket_count (STL/CLR)	Viene calcolato il numero dei bucket.
hash_multimap::clear (STL/CLR)	Rimuove tutti gli elementi.
hash_multimap::count (STL/CLR)	Conta gli elementi che soddisfano una chiave specificata.
hash_multimap::empty (STL/CLR)	Consente di verificare se non sono presenti elementi.
hash_multimap::end (STL/CLR)	Definisce la fine della sequenza controllata.
hash_multimap::equal_range (STL/CLR)	I rileva variano che corrisponde a una chiave specificata.
hash_multimap::erase (STL/CLR)	Rimuove gli elementi alle posizioni specificate.
hash_multimap::find (STL/CLR)	Viene trovato un elemento che corrisponde alla chiave specificata.
hash_multimap::hash_delegate (STL/CLR)	Copiare il delegato di hashing di una chiave.
hash_multimap::hash_multimap (STL/CLR)	Costruisce un oggetto contenitore.
hash_multimap::insert (STL/CLR)	Aggiunge elementi.
hash_multimap::key_comp (STL/CLR)	Copiare il delegato dell'ordine per due chiavi.
hash_multimap::load_factor (STL/CLR)	Conta gli elementi e l'altro per bucket.
hash_multimap::lower_bound (STL/CLR)	Individuare l'inizio dell'intervallo che corrisponde a una chiave specificata.
hash_multimap::make_value (STL/CLR)	Costruisce un oggetto di valore.
hash_multimap::max_load_factor (STL/CLR)	Ottiene o imposta elementi massimo per bucket.
hash_multimap::rbegin (STL/CLR)	Definisce l'inizio della sequenza inversa controllata.
hash_multimap::rehash (STL/CLR)	Ricompila la tabella hash.
hash_multimap::rend (STL/CLR)	Definisce la fine della sequenza inversa controllata.
hash_multimap::size (STL/CLR)	Conta il numero di elementi.
hash_multimap::swap (STL/CLR)	Scambia il contenuto di due contenitori.
hash_multimap::to_array (STL/CLR)	Copia la sequenza selezionata una nuova matrice.
hash_multimap::upper_bound (STL/CLR)	Fine preleva di temporizzazione che corrisponde a una chiave specificata.
hash_multimap::value_comp (STL/CLR)	Copiare il delegato dell'ordine per due valori degli elementi.

Operatore	Descrizione
hash_multimap::operator= (STL/CLR)	Sostituisce la sequenza selezionata.

Interfacce

Interfaccia	Descrizione
ICloneable	Duplicare un oggetto.
IEnumerable	Sequenza degli elementi.
ICollection	Gestire il gruppo di elementi.
IEnumerable	Sequenza dagli elementi tipizzati.
ICollection	Gestire il gruppo di elementi tipizzati.
IHashKey<, valore>	Gestire il contenitore generico.

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 a lunghezza dei puntatori nell'elenco (la tabella hash), efficiente senza modificare l'elenco di tutto come sequenza di sottoelenchi, o i bucket. Non inserire mai gli elementi in un bucket che mantiene ordinato cambiando i collegamenti tra i nodi, copia il contenuto di un nodo a un altro. Ciò significa che è possibile inserire liberamente e rimuovere elementi senza pregiudicare 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 all'oggetto delegato 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 i 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, in X e Y causate da 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 modo che solo gli elementi la cui le chiavi sono equivalenti (ordine e con hash sullo stesso valore Integer) siano adiacenti all'interno di un bucket. A differenza della classe modello hash_map (STL/CLR), un oggetto classe modello hash_multimap non richiede che le chiavi per tutti gli elementi siano univoche. (Due o più chiavi possono avere ordine equivalente.)

L'oggetto determina quali 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 Integer 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 ordine è equivalente, quindi hash_delegate()(X) deve restituire lo stesso risultato intero 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 (temporale lineare). Il contenitore tenta di scegliere una funzione hash ragionevole, una dimensione media del bucket e una dimensione hashtable (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_multimap 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_multimap::end (STL/CLR)(). È possibile diminuire questo iteratore per ottenere l'ultimo elemento della sequenza selezionata, se presente. È possibile incrementare un iteratore di hash_multimap per ottenere il nodo head quindi confronterà il segno di uguale a end(). Ma non è possibile dereferenziare l'iteratore restituito da end().

Si noti che non è possibile fare riferimento a un elemento del hash_multimap fornito direttamente la posizione numerica -- ciò richiede un iteratore di accesso casuale.

Un iteratore di hash_multimap memorizzare l'handle al nodo collegato di hash_multimap, che a sua volta memorizzare l'handle al relativo contenitore collegato. È possibile utilizzare gli iteratori solo con i relativi oggetti contenitore collegati. Un iteratore di hash_multimap rimane valido a condizione che il relativo nodo collegato di hash_multimap è associato ad alcuni hash_multimap. 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().

Clearing or rimozione di un elemento chiama il distruttore per il valore archiviato. Eliminare il contenitore di cancellare tutti gli elementi. Pertanto, un contenitore del cui tipo di elemento è una classe di riferimento garantisce che nessun elemento sopravviva il contenitore. Nota, tuttavia, che un contenitore handles fa not eliminato i relativi elementi.