hash_set (STL/CLR)
La classe modello descrive un oggetto che comandi di una sequenza variare lunghezza di elementi che ha accesso bidirezionale. Utilizzare il contenitore hash_set 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. Il valore di ciascun elemento viene utilizzato come chiave, ordinare la sequenza.
In descrizione di seguito, GValue sono gli stessi di GKey, che a sua volta corrispondano a quelli di Key eccetto l'ultimo sia un tipo di riferimento, nel qual caso viene Key^.
template<typename Key>
ref class hash_set
: 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.
Membri
Definizione del tipo |
Descrizione |
|---|---|
Il tipo di un iteratore costante della sequenza controllata. |
|
Il tipo di un riferimento costante a un elemento. |
|
Il tipo di iteratore inverso costante per la sequenza selezionata. |
|
Il tipo di distanza (eventualmente firmata) tra due elementi. |
|
Il tipo dell'interfaccia generica del contenitore. |
|
Il tipo di iteratore per l'interfaccia generica del contenitore. |
|
Il tipo di iteratore inverso per l'interfaccia generica del contenitore. |
|
Il tipo di elemento dell'interfaccia generica del contenitore. |
|
Il delegato di hashing di una chiave. |
|
Il tipo di un iteratore della sequenza controllata. |
|
Il delegato dell'ordine per due chiavi. |
|
Il tipo di una chiave di ordinamento. |
|
Il tipo di un riferimento a un elemento. |
|
Il tipo di iteratore inverso per la sequenza selezionata. |
|
Il tipo di distanza (non negativa) a tra due elementi. |
|
Il delegato dell'ordine per due valori degli elementi. |
|
Il tipo di un elemento. |
Funzione membro |
Descrizione |
|---|---|
Definisce l'inizio della sequenza controllata. |
|
Viene calcolato il numero dei bucket. |
|
Rimuove tutti gli elementi. |
|
Conta gli elementi che soddisfano una chiave specificata. |
|
Consente di verificare se non sono presenti elementi. |
|
Definisce la fine della sequenza controllata. |
|
I rileva variano che corrisponde a una chiave specificata. |
|
Rimuove gli elementi alle posizioni specificate. |
|
Viene trovato un elemento che corrisponde alla chiave specificata. |
|
Copiare il delegato di hashing di una chiave. |
|
Costruisce un oggetto contenitore. |
|
Aggiunge elementi. |
|
Copiare il delegato dell'ordine per due chiavi. |
|
Conta gli elementi e l'altro per bucket. |
|
Individuare l'inizio dell'intervallo che corrisponde a una chiave specificata. |
|
Costruisce un oggetto di valore. |
|
Ottiene o imposta elementi massimo per bucket. |
|
Definisce l'inizio della sequenza inversa controllata. |
|
Ricompila la tabella hash. |
|
Definisce la fine della sequenza inversa controllata. |
|
Conta il numero di elementi. |
|
Scambia il contenuto di due contenitori. |
|
Copia la sequenza selezionata una nuova matrice. |
|
Fine preleva di temporizzazione che corrisponde a una chiave specificata. |
|
Copiare il delegato dell'ordine per due valori degli elementi. |
Operatore |
Descrizione |
|---|---|
Sostituisce la sequenza selezionata. |
Interfacce
Interfaccia |
Descrizione |
|---|---|
Duplicare un oggetto. |
|
Sequenza degli elementi. |
|
Gestire il gruppo di elementi. |
|
Sequenza dagli elementi tipizzati. |
|
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_multiset (STL/CLR), un oggetto classe modello hash_set garantisce che le chiavi per tutti gli elementi siano univoche. (Non esistono due chiavi di ordinamento 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 viene utilizzato sia chiave che valore. 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_set 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_set::end (STL/CLR)(). È possibile diminuire questo iteratore per ottenere l'ultimo elemento della sequenza selezionata, se presente. È possibile incrementare un iteratore di hash_set 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_set fornito direttamente la posizione numerica -- ciò richiede un iteratore di accesso casuale.
Un iteratore di hash_set memorizzare l'handle al nodo collegato di hash_set, 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_set rimane valido a condizione che il relativo nodo collegato di hash_set è associato ad alcuni hash_set. 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.
Requisiti
Intestazione:<cliext/hash_set>
Spazio dei nomi: cliext