Condividi tramite


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 map per gestire una sequenza di elementi come (quasi) è bilanciato la struttura ad albero ordinato di nodi, ogni un elemento archiviante.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 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::ITree<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

map::const_iterator (STL/CLR)

Il tipo di iteratore costante per la sequenza selezionata.

map::const_reference (STL/CLR)

Il tipo di riferimento costante a un elemento.

map::const_reverse_iterator (STL/CLR)

Il tipo di iteratore inverso costante per la sequenza selezionata.

map::difference_type (STL/CLR)

Il tipo di distanza (possibilmente con segno) tra due elementi.

map::generic_container (STL/CLR)

Il tipo dell'interfaccia generica per il contenitore.

map::generic_iterator (STL/CLR)

il tipo di iteratore per l'interfaccia generica per il contenitore.

map::generic_reverse_iterator (STL/CLR)

il tipo di iteratore inverso per l'interfaccia generica per il contenitore.

map::generic_value (STL/CLR)

il tipo di elemento per l'interfaccia generica per il contenitore.

map::iterator (STL/CLR)

Il tipo di iteratore per la sequenza selezionata.

map::key_compare (STL/CLR)

Il delegato dell'ordine per due chiavi.

map::key_type (STL/CLR)

Il tipo di chiave di ordinamento.

map::mapped_type (STL/CLR)

Il tipo del valore mappato associato a ogni chiave.

map::reference (STL/CLR)

Il tipo di riferimento a un elemento.

map::reverse_iterator (STL/CLR)

Il tipo di iteratore inverso per la sequenza selezionata.

map::size_type (STL/CLR)

Il tipo di distanza (non negativa) di un oggetto tra due elementi.

map::value_compare (STL/CLR)

Il delegato dell'ordine per due valori dell'elemento.

map::value_type (STL/CLR)

Il tipo di elemento.

Funzione membro

Descrizione

map::begin (STL/CLR)

Definisce l'inizio della sequenza controllata.

map::clear (STL/CLR)

Rimuove tutti gli elementi.

map::count (STL/CLR)

Conta gli elementi che soddisfano una chiave specificata.

map::empty (STL/CLR)

Verifica se non sono presenti elementi presenti.

map::end (STL/CLR)

Definisce la fine della sequenza controllata.

map::equal_range (STL/CLR)

I trova variano che corrisponde a una chiave specificata.

map::erase (STL/CLR)

Rimuove gli elementi alle posizioni specificate.

map::find (STL/CLR)

Viene trovato un elemento che corrisponde alla chiave specificata.

map::insert (STL/CLR)

Aggiunge gli elementi.

map::key_comp (STL/CLR)

Copia il delegato dell'ordine per due chiavi.

map::lower_bound (STL/CLR)

Rileva l'inizio dell'intervallo che corrisponde a una chiave specificata.

map::make_value (STL/CLR)

Costruisce un oggetto di valore.

map::map (STL/CLR)

Costruisce un oggetto contenitore.

map::rbegin (STL/CLR)

Definisce l'inizio della sequenza inversa controllata.

map::rend (STL/CLR)

Definisce la fine della sequenza inversa controllata.

map::size (STL/CLR)

Conta il numero di elementi.

map::swap (STL/CLR)

Scambia il contenuto di due contenitori.

map::to_array (STL/CLR)

Copia la sequenza selezionata in una nuova matrice.

map::upper_bound (STL/CLR)

Fine di individuare di temporizzazione che corrisponde a una chiave specificata.

map::value_comp (STL/CLR)

Copia il delegato dell'ordine per due valori dell'elemento.

Operatore

Descrizione

map::operator= (STL/CLR)

Sostituisce la sequenza selezionata.

map::operator[] (STL/CLR)

Esegue il mapping di una chiave al valore mappato associato.

operator!= (map) (STL/CLR)

Determina se un oggetto di map non è uguale a un altro oggetto di map .

operator< (map) (STL/CLR)

Determina se un oggetto di map è inferiore a un altro oggetto di map .

operator<= (map) (STL/CLR)

Determina se un oggetto di map è minore o uguale a un altro oggetto di map .

operator== (map) (STL/CLR)

Determina se un oggetto di map equivale a un altro oggetto di map .

operator> (map) (STL/CLR)

Determina se un oggetto di map è maggiore di un altro oggetto di map .

operator>= (map) (STL/CLR)

Determina se un oggetto di map è maggiore o uguale a un altro oggetto di map .

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.

IDictionary<TKey, TValue>

Gestire il gruppo chiave {,} valore di coppie.

ITree<chiave, valore>

gestire il contenitore generico.

Note

L'oggetto alloca e libera la memoria per la sequenza che controlla come singoli nodi.Inserisce gli elementi in un oggetto (quasi) non è bilanciato la struttura ad albero che lo mantiene ordinato modifica dei collegamenti tra i nodi, mai copiando 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 la sequenza che controlla chiamando un oggetto delegato archiviato di tipo map::key_compare (STL/CLR).È possibile specificare l'oggetto delegato archiviato quando si crea il mapping; se non si specifica oggetto delegato, l'impostazione predefinita è il confronto operator<(key_type, key_type).È possibile accedere a questo oggetto archiviato chiamando la funzione membro map::key_comp (STL/CLR)().

Tale oggetto delegato necessario imporre un ordine debole rigido le chiavi di tipo map::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) è true, quindi key_comp()(Y, X) deve essere false.

Se key_comp()(X, Y) è true, quindi X sarebbe ordinato prima di Y.

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

Per qualsiasi elemento X che precede Y nella sequenza selezionata, key_comp()(Y, X) è false.(Per l'oggetto delegato predefinito, chiavi non diminuiscono mai il valore.) A differenza della classe modello map (STL/CLR), un oggetto di classe modello map non richiede che le chiavi per tutti gli elementi siano univoche.(Due o più tasti possono avere ordine equivalente.)

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 proporzionali al logaritmo del numero di elementi della sequenza (tempo logaritmico).Inoltre, inserendo un elemento non invalida iteratori e la rimozione di un elemento invalida solo gli iteratori che puntano all'elemento rimosso.

Un mapping 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 map::end (STL/CLR)().È possibile diminuire questo iteratore per ottenere ultimo elemento nella sequenza selezionata, se presente.È possibile incrementare un iteratore di mapping 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 mapping direttamente in base alla posizione numerica -- ciò richiede un iteratore di accesso casuale.

Un iteratore di mapping memorizzare l'handle al nodo associato al mapping, 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 mapping rimane valido a condizione che il relativo nodo associato al mapping è associato ad alcuni mapping.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/mapping>

Cliext diSpazio dei nomi:

Vedere anche

Riferimenti

hash_map (STL/CLR)

hash_map (STL/CLR)

hash_multiset (STL/CLR)

hash_set (STL/CLR)

map (STL/CLR)

multiset (STL/CLR)

set (STL/CLR)

Altre risorse

Riferimenti alla libreria STL/CLR