hash_set (STL/CLR)

Articolo
06/07/2013

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_set 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.Il valore di ogni elemento viene utilizzato come chiave, per ordinare la sequenza.

Nella descrizione di seguito, GValue sono gli stessi di GKey, che a sua volta è lo stesso di Key a meno che quest'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
hash_set::const_iterator (STL/CLR)	Il tipo di iteratore costante per la sequenza selezionata.
hash_set::const_reference (STL/CLR)	Il tipo di riferimento costante a un elemento.
hash_set::const_reverse_iterator (STL/CLR)	Il tipo di iteratore inverso costante per la sequenza selezionata.
hash_set::difference_type (STL/CLR)	Il tipo di distanza (possibilmente con segno) tra due elementi.
hash_set::generic_container (STL/CLR)	Il tipo dell'interfaccia generica per il contenitore.
hash_set::generic_iterator (STL/CLR)	il tipo di iteratore per l'interfaccia generica per il contenitore.
hash_set::generic_reverse_iterator (STL/CLR)	il tipo di iteratore inverso per l'interfaccia generica per il contenitore.
hash_set::generic_value (STL/CLR)	il tipo di elemento per l'interfaccia generica per il contenitore.
hash_set::hasher (STL/CLR)	Il delegato di hashing di una chiave.
hash_set::iterator (STL/CLR)	Il tipo di iteratore per la sequenza selezionata.
hash_set::key_compare (STL/CLR)	Il delegato dell'ordine per due chiavi.
hash_set::key_type (STL/CLR)	Il tipo di chiave di ordinamento.
hash_set::reference (STL/CLR)	Il tipo di riferimento a un elemento.
hash_set::reverse_iterator (STL/CLR)	Il tipo di iteratore inverso per la sequenza selezionata.
hash_set::size_type (STL/CLR)	Il tipo di distanza (non negativa) di un oggetto tra due elementi.
hash_set::value_compare (STL/CLR)	Il delegato dell'ordine per due valori dell'elemento.
hash_set::value_type (STL/CLR)	Il tipo di elemento.

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

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

Interfacce

Interfaccia	Descrizione
ICloneable	Clonare un oggetto.
IEnumerable	Sequenza degli elementi.
ICollection	gestire il gruppo di elementi.
IEnumerable<T>	Sequenza degli elementi tipizzati.
ICollection<T>	gestire il gruppo di elementi tipizzati.
IHash<chiave, 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 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_multiset (STL/CLR), un oggetto di classe modello hash_set 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 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 (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_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 ultimo elemento nella sequenza selezionata, se presente.È possibile incrementare un iteratore di hash_set 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_set direttamente in base alla posizione numerica -- ciò richiede un iteratore di accesso casuale.

Un iteratore di hash_set memorizzare l'handle al nodo associato al hash_set, 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_set rimane valido a condizione che il relativo nodo associato al hash_set essere associato a un certo 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().

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.