`hash_multiset` (STL/CLR)

Articolo
10/12/2023

La classe modello descrive un oggetto che controlla una sequenza di elementi di lunghezza variabile con accesso bidirezionale. Usare il contenitore hash_multiset per gestire una sequenza di elementi come tabella hash, ogni voce di tabella che archivia un elenco di nodi collegati bidirezionali e ogni nodo che archivia un elemento. Il valore di ogni elemento viene usato come chiave per ordinare la sequenza.

Nella descrizione seguente GValue è uguale a GKey, che a sua volta è uguale Key a , a meno che quest'ultimo non sia un tipo ref, nel qual caso è Key^.

Sintassi

template<typename Key>
    ref class hash_multiset
        :   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

Key
Tipo del componente chiave di un elemento nella sequenza controllata.

Requisiti

Intestazione:<cliext/hash_set>

Spazio dei nomi: cliext

Dichiarazioni

Definizione dei tipi	Descrizione
`hash_multiset::const_iterator`	Tipo di un iteratore costante per la sequenza controllata.
`hash_multiset::const_reference`	Tipo di un riferimento costante a un elemento.
`hash_multiset::const_reverse_iterator`	Tipo di un iteratore inverso costante per la sequenza controllata.
`hash_multiset::difference_type`	Tipo di distanza (possibilmente firmata) tra due elementi.
`hash_multiset::generic_container`	Tipo dell'interfaccia generica per il contenitore.
`hash_multiset::generic_iterator`	Tipo di iteratore per l'interfaccia generica per il contenitore.
`hash_multiset::generic_reverse_iterator`	Tipo di iteratore inverso per l'interfaccia generica per il contenitore.
`hash_multiset::generic_value`	Tipo di elemento per l'interfaccia generica per il contenitore.
`hash_multiset::hasher`	Delegato hash per una chiave.
`hash_multiset::iterator`	Tipo di un iteratore per la sequenza controllata.
`hash_multiset::key_compare`	Delegato di ordinamento per due chiavi.
`hash_multiset::key_type`	Tipo di una chiave di ordinamento.
`hash_multiset::reference`	Tipo di un riferimento a un elemento.
`hash_multiset::reverse_iterator`	Tipo di un iteratore inverso della sequenza controllata.
`hash_multiset::size_type`	Tipo di distanza (non negativa) tra due elementi.
`hash_multiset::value_compare`	Delegato di ordinamento per due valori di elemento.
`hash_multiset::value_type`	Tipo di un elemento.

Funzione membro	Descrizione
`hash_multiset::begin`	Indica l'inizio della sequenza controllata.
`hash_multiset::bucket_count`	Conta il numero di bucket.
`hash_multiset::clear`	Rimuove tutti gli elementi.
`hash_multiset::count`	Conta gli elementi corrispondenti a una chiave specificata.
`hash_multiset::empty`	Verifica se sono presenti o meno degli elementi.
`hash_multiset::end`	Designa la fine della sequenza controllata.
`hash_multiset::equal_range`	Trova un intervallo che corrisponde a una chiave specificata.
`hash_multiset::erase`	Rimuove gli elementi in corrispondenza delle posizioni specificate.
`hash_multiset::find`	Trova un elemento che corrisponde a una chiave specificata.
`hash_multiset::hash_delegate`	Copia il delegato di hash per una chiave.
`hash_multiset::hash_multiset`	Costruisce un oggetto contenitore.
`hash_multiset::insert`	Aggiunge elementi.
`hash_multiset::key_comp`	Copia il delegato di ordinamento per due chiavi.
`hash_multiset::load_factor`	Conta il numero medio di elementi per bucket.
`hash_multiset::lower_bound`	Trova l'inizio dell'intervallo che corrisponde a una chiave specificata.
`hash_multiset::make_value`	Costruisce un oggetto valore.
`hash_multiset::max_load_factor`	Ottiene o imposta il numero massimo di elementi per bucket.
`hash_multiset::rbegin`	Indica l'inizio della sequenza controllata inversa.
`hash_multiset::rehash`	Ricompila la tabella hash.
`hash_multiset::rend`	Indica la fine della sequenza controllata inversa.
`hash_multiset::size`	Conta il numero di elementi.
`hash_multiset::swap`	Scambia il contenuto di due contenitori.
`hash_multiset::to_array`	Copia la sequenza controllata in una nuova matrice.
`hash_multiset::upper_bound`	Trova la fine dell'intervallo che corrisponde a una chiave specificata.
`hash_multiset::value_comp`	Copia il delegato di ordinamento per due valori di elemento.

Operatore	Descrizione
`hash_multiset::operator=`	Sostituisce la sequenza controllata.

Interfacce

Interfaccia	Descrizione
ICloneable	Duplicare un oggetto .
IEnumerable	Sequenzia tra elementi.
ICollection	Mantenere il gruppo di elementi.
IEnumerable<T>	Sequenzia tra elementi tipizzato.
ICollection<T>	Mantenere un gruppo di elementi tipizzato.
`IHash<Key, Value>`	Gestire un contenitore generico.

Osservazioni:

L'oggetto alloca e libera l'archiviazione per la sequenza che controlla come singoli nodi in un elenco collegato bidirezionale. Per velocizzare l'accesso, l'oggetto mantiene anche una matrice di puntatori a lunghezza variabile nell'elenco (tabella hash), gestendo in modo efficace l'intero elenco come sequenza di sottoliste o bucket. Inserisce gli elementi in un bucket che mantiene ordinato modificando i collegamenti tra i nodi, non copiando mai il contenuto di un nodo in un altro. Ciò significa che è possibile inserire e rimuovere liberamente elementi senza disturbare gli elementi rimanenti.

L'oggetto ordina ogni bucket che controlla chiamando un oggetto delegato archiviato di tipo hash_set::key_compare. È possibile specificare l'oggetto delegato archiviato quando si costruisce il hash_set; se non si specifica alcun oggetto delegato, il valore predefinito è il confronto operator<=(key_type, key_type).

Per accedere all'oggetto delegato archiviato, chiamare la funzione hash_set::key_compmembro . Tale oggetto delegato deve definire un ordinamento equivalente tra le chiavi di tipo hash_set::key_type. Ciò significa che per due chiavi X e Y:

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

Se key_comp()(X, Y) && key_comp()(Y, X) è true, X e Y viene detto di avere un ordinamento equivalente.

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

Il contenitore garantisce solo che gli elementi le cui chiavi abbiano un ordinamento equivalente (e che hash allo stesso valore intero) siano adiacenti all'interno di un bucket. A differenza della classe hash_set modello (STL/CLR), un oggetto della classe hash_multiset modello non richiede che le chiavi per tutti gli elementi siano univoche. Due o più chiavi possono avere un ordinamento equivalente.

L'oggetto determina quale bucket deve contenere una chiave di ordinamento specifica chiamando un oggetto delegato archiviato di tipo hash_set::hasher. Per accedere a questo oggetto archiviato, chiamare la funzione hash_set::hash_delegate membro per ottenere un valore intero che dipende dal valore della chiave. È possibile specificare l'oggetto delegato archiviato quando si costruisce il hash_set; se non si specifica alcun oggetto delegato, il valore predefinito è la funzione System::Object::hash_value(key_type). Ciò significa che, per qualsiasi chiave X e Y:

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

Se X e Y hanno un ordinamento equivalente, hash_delegate()(X) deve restituire lo stesso risultato intero di hash_delegate()(Y).

Ogni elemento funge sia da chiave che da valore. La sequenza viene rappresentata in modo da consentire la ricerca, l'inserimento e la rimozione di un elemento arbitrario in tempo costante. Ovvero, il numero di operazioni è indipendente dal numero di elementi nella sequenza, almeno nel migliore dei casi. Inoltre, l'inserimento di un elemento non invalida alcun iteratore e la rimozione di un elemento invalida solo gli iteratori che puntano all'elemento rimosso.

Se i valori con hash non vengono distribuiti in modo uniforme, tuttavia, una tabella hash può degenerare. Nell'estremo (per una funzione hash che restituisce sempre lo stesso valore), la ricerca, l'inserimento e la rimozione sono proporzionali al numero di elementi nella sequenza (tempo lineare). Il contenitore tenta di scegliere una funzione hash ragionevole, le dimensioni medie del bucket e le dimensioni della tabella hash (numero totale di bucket), ma è possibile eseguire l'override di qualsiasi o di tutte queste scelte. Vedere, ad esempio, le funzioni hash_set::max_load_factor e hash_set::rehash.

Un hash_multiset oggetto supporta iteratori bidirezionali, il che significa che è possibile passare agli elementi adiacenti in base a un iteratore che designa un elemento nella sequenza controllata. Un nodo head speciale corrisponde all'iteratore restituito da hash_multiset::end. È possibile decrementare questo iteratore per raggiungere l'ultimo elemento nella sequenza controllata, se presente. È possibile incrementare un hash_multiset iteratore per raggiungere il nodo head e quindi confrontarlo con end(). Non è tuttavia possibile dereferenziare l'iteratore restituito da end().

Non è possibile fare riferimento a un hash_multiset elemento direttamente in base alla relativa posizione numerica. Questo richiede un iteratore ad accesso casuale.

Un hash_multiset iteratore archivia un handle al nodo associato hash_multiset , che a sua volta archivia un handle per il contenitore associato. È possibile usare gli iteratori solo con gli oggetti contenitore associati. Un hash_multiset iteratore rimane valido fino a quando il nodo associato hash_multiset è associato ad alcuni hash_multiset. Inoltre, un iteratore valido è dereferenziabile. È possibile usarlo per accedere o modificare il valore dell'elemento designato, purché non sia uguale a end().

Cancellare o rimuovere un elemento chiama il distruttore per il valore archiviato. L'eliminazione definitiva del contenitore cancella tutti gli elementi. Pertanto, un contenitore il cui tipo di elemento è una classe ref garantisce che nessun elemento scadeni il contenitore. Tuttavia, un contenitore di handle non elimina definitivamente i relativi elementi.

Membri

`hash_multiset::begin`

Indica l'inizio della sequenza controllata.

Sintassi

iterator begin();

Osservazioni:

La funzione membro restituisce un iteratore bidirezionale che definisce il primo elemento della sequenza controllata o appena oltre la fine di una sequenza vuota. Viene usato per ottenere un iteratore che designa l'inizio current della sequenza controllata, ma il relativo stato può cambiare se la lunghezza della sequenza controllata cambia.

Esempio

// cliext_hash_multiset_begin.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    Myhash_multiset::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);
    return (0);
    }

a b c
*begin() = a
*++begin() = b

`hash_multiset::bucket_count`

Conta il numero di bucket.

Sintassi

int bucket_count();

Osservazioni:

La funzione membro restituisce il numero corrente di bucket. Viene usato per determinare le dimensioni della tabella hash.

Esempio

// cliext_hash_multiset_bucket_count.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

`hash_multiset::clear`

Rimuove tutti gli elementi.

Sintassi

void clear();

Osservazioni:

La funzione membro chiama erase(begin(), end())in modo efficace . Viene usato per assicurarsi che la sequenza controllata sia vuota.

Esempio

// cliext_hash_multiset_clear.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    // add elements and clear again
    c1.insert(L'a');
    c1.insert(L'b');

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
size() = 0
a b
size() = 0

`hash_multiset::const_iterator`

Tipo di un iteratore costante per la sequenza controllata.

Sintassi

typedef T2 const_iterator;

Osservazioni:

Il tipo descrive un oggetto di tipo T2 non specificato che può fungere da iteratore bidirezionale costante per la sequenza controllata.

Esempio

// cliext_hash_multiset_const_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    Myhash_multiset::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }

a b c

`hash_multiset::const_reference`

Tipo di un riferimento costante a un elemento.

Sintassi

typedef value_type% const_reference;

Osservazioni:

Il tipo descrive un riferimento costante a un elemento.

Esempio

// cliext_hash_multiset_const_reference.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    Myhash_multiset::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Myhash_multiset::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`hash_multiset::const_reverse_iterator`

Tipo di un iteratore inverso costante per la sequenza controllata.

Sintassi

typedef T4 const_reverse_iterator;

Osservazioni:

Il tipo descrive un oggetto di tipo T4 non specificato che può fungere da iteratore inverso costante per la sequenza controllata.

Esempio

// cliext_hash_multiset_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" reversed
    Myhash_multiset::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }

c b a

`hash_multiset::count`

Trova il numero di elementi corrispondenti a una chiave specificata.

Sintassi

size_type count(key_type key);

Parametri

key
Valore della chiave da cercare.

Osservazioni:

La funzione membro restituisce il numero di elementi nella sequenza controllata che hanno un ordinamento equivalente con key. Viene usato per determinare il numero di elementi attualmente presenti nella sequenza controllata che corrispondono a una chiave specificata.

Esempio

// cliext_hash_multiset_count.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("count(L'A') = {0}", c1.count(L'A'));
    System::Console::WriteLine("count(L'b') = {0}", c1.count(L'b'));
    System::Console::WriteLine("count(L'C') = {0}", c1.count(L'C'));
    return (0);
    }

a b c
count(L'A') = 0
count(L'b') = 1
count(L'C') = 0

`hash_multiset::difference_type`

Tipi di distanza con segno tra due elementi.

Sintassi

typedef int difference_type;

Osservazioni:

Il tipo descrive un numero di elementi potenzialmente negativo.

Esempio

// cliext_hash_multiset_difference_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    Myhash_multiset::difference_type diff = 0;
    for (Myhash_multiset::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (Myhash_multiset::iterator it = c1.end(); it != c1.begin(); --it)
        --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3
begin()-end() = -3

`hash_multiset::empty`

Verifica se sono presenti o meno degli elementi.

Sintassi

bool empty();

Osservazioni:

La funzione membro restituisce true per una sequenza controllata vuota. È equivalente a size() == 0. Viene usato per verificare se l'oggetto hash_multiset è vuoto.

Esempio

// cliext_hash_multiset_empty.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

a b c
size() = 3
empty() = False
size() = 0
empty() = True

`hash_multiset::end`

Designa la fine della sequenza controllata.

Sintassi

iterator end();

Osservazioni:

La funzione membro restituisce un iteratore bidirezionale che punta appena oltre la fine della sequenza controllata. Lo si usa per ottenere un iteratore che designa la fine della sequenza controllata; lo stato non cambia se la lunghezza della sequenza controllata cambia.

Esempio

// cliext_hash_multiset_end.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last two items
    Myhash_multiset::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);
    return (0);
    }

a b c
*-- --end() = b
*--end() = c

`hash_multiset::equal_range`

Trova un intervallo che corrisponde a una chiave specificata.

Sintassi

cliext::pair<iterator, iterator> equal_range(key_type key);

Parametri

key
Valore della chiave da cercare.

Osservazioni:

La funzione membro restituisce una coppia di iteratori cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key)). Viene usato per determinare l'intervallo di elementi attualmente presenti nella sequenza controllata che corrispondono a una chiave specificata.

Esempio

// cliext_hash_multiset_equal_range.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
typedef Myhash_multiset::pair_iter_iter Pairii;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display results of failed search
    Pairii pair1 = c1.equal_range(L'x');
    System::Console::WriteLine("equal_range(L'x') empty = {0}",
        pair1.first == pair1.second);

    // display results of successful search
    pair1 = c1.equal_range(L'b');
    for (; pair1.first != pair1.second; ++pair1.first)
        System::Console::Write("{0} ", *pair1.first);
    System::Console::WriteLine();
    return (0);
    }

a b c
equal_range(L'x') empty = True
b

`hash_multiset::erase`

Rimuove gli elementi in corrispondenza delle posizioni specificate.

Sintassi

iterator erase(iterator where);
iterator erase(iterator first, iterator last);
bool erase(key_type key)

Parametri

first
Inizio dell'intervallo da cancellare.

key
Valore della chiave da cancellare.

last
Fine dell'intervallo da cancellare.

where
Elemento da cancellare.

Osservazioni:

La prima funzione membro rimuove l'elemento della sequenza controllata a wherecui punta e restituisce un iteratore che designa il primo elemento rimanente oltre l'elemento rimosso o end() se tale elemento non esiste. Viene usato per rimuovere un singolo elemento.

La seconda funzione membro rimuove gli elementi della sequenza controllata nell'intervallo [first, last) e restituisce un iteratore che designa il primo elemento rimanente oltre gli elementi rimossi o end() se tale elemento non esiste. È possibile usarlo per rimuovere zero o più elementi contigui.

La terza funzione membro rimuove qualsiasi elemento della sequenza controllata la cui chiave ha un ordinamento equivalente a keye restituisce un conteggio del numero di elementi rimossi. Viene usato per rimuovere e contare tutti gli elementi che corrispondono a una chiave specificata.

Ogni cancellazione degli elementi richiede tempo proporzionale al logaritmo del numero di elementi nella sequenza controllata.

Esempio

// cliext_hash_multiset_erase.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase an element and reinspect
    System::Console::WriteLine("erase(begin()) = {0}",
        *c1.erase(c1.begin()));

    // add elements and display " b c d e"
    c1.insert(L'd');
    c1.insert(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase all but end
    Myhash_multiset::iterator it = c1.end();
    System::Console::WriteLine("erase(begin(), end()-1) = {0}",
        *c1.erase(c1.begin(), --it));
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1

`hash_multiset::find`

Trova un elemento che corrisponde a una chiave specificata.

Sintassi

iterator find(key_type key);

Parametri

key
Valore della chiave da cercare.

Osservazioni:

Se almeno un elemento della sequenza controllata ha un ordinamento equivalente con key, la funzione membro restituisce un iteratore che designa uno di questi elementi; in caso contrario, restituisce end(). È possibile usarlo per individuare un elemento attualmente nella sequenza controllata che corrisponde a una chiave specificata.

Esempio

// cliext_hash_multiset_find.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("find {0} = {1}",
        L'A', c1.find(L'A') != c1.end());
    System::Console::WriteLine("find {0} = {1}",
        L'b', *c1.find(L'b'));
    System::Console::WriteLine("find {0} = {1}",
        L'C', c1.find(L'C') != c1.end());
    return (0);
    }

a b c
find A = False
find b = b
find C = False

`hash_multiset::generic_container`

Tipo dell'interfaccia generica per il contenitore.

Sintassi

typedef Microsoft::VisualC::StlClr::
    IHash<GKey, GValue>
    generic_container;

Osservazioni:

Il tipo descrive l'interfaccia generica per questa classe contenitore modello.

Esempio

// cliext_hash_multiset_generic_container.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multiset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify original and display generic
    c1.insert(L'e');
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a b c d
a b c d e

`hash_multiset::generic_iterator`

Tipo di iteratore da usare con l'interfaccia generica per il contenitore.

Sintassi

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerBidirectionalIterator<generic_value>
    generic_iterator;

Osservazioni:

Il tipo descrive un iteratore generico che può essere usato con l'interfaccia generica per questa classe contenitore modello.

Esempio

// cliext_hash_multiset_generic_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multiset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_multiset::generic_iterator gcit = gc1->begin();
    Myhash_multiset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
a

`hash_multiset::generic_reverse_iterator`

Tipo di iteratore inverso da usare con l'interfaccia generica per il contenitore.

Sintassi

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value>
    generic_reverse_iterator;

Osservazioni:

Il tipo descrive un iteratore inverso generico che può essere usato con l'interfaccia generica per questa classe contenitore modello.

Esempio

// cliext_hash_multiset_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multiset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_multiset::generic_reverse_iterator gcit = gc1->rbegin();
    Myhash_multiset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
c

`hash_multiset::generic_value`

Tipo di un elemento da usare con l'interfaccia generica per il contenitore.

Sintassi

typedef GValue generic_value;

Osservazioni:

Il tipo descrive un oggetto di tipo GValue che descrive il valore dell'elemento archiviato da usare con l'interfaccia generica per questa classe contenitore modello.

Esempio

// cliext_hash_multiset_generic_value.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multiset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_multiset::generic_iterator gcit = gc1->begin();
    Myhash_multiset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
a

`hash_multiset::hash_delegate`

Trova un elemento che corrisponde a una chiave specificata.

Sintassi

hasher^ hash_delegate();

Osservazioni:

La funzione membro restituisce il delegato utilizzato per convertire un valore di chiave in un numero intero. Viene usato per eseguire l'hashing di una chiave.

Esempio

// cliext_hash_multiset_hash_delegate.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::hasher^ myhash = c1.hash_delegate();

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }

hash(L'a') = 1616896120
hash(L'b') = 570892832

`hash_multiset::hash_multiset`

Costruisce un oggetto contenitore.

Sintassi

hash_multiset();
explicit hash_multiset(key_compare^ pred);
hash_multiset(key_compare^ pred, hasher^ hashfn);
hash_multiset(hash_multiset<Key>% right);
hash_multiset(hash_multiset<Key>^ right);
template<typename InIter>
    hash_multiset(InIter first, InIter last);
template<typename InIter>
    hash_multiset(InIter first, InIter last,
        key_compare^ pred);
template<typename InIter>
    hash_multiset(InIter first, InIter last,
        key_compare^ pred, hasher^ hashfn);
hash_multiset(System::Collections::Generic::IEnumerable<GValue>^ right);
hash_multiset(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred);
hash_multiset(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred, hasher^ hashfn);

Parametri

first
Inizio dell'intervallo da inserire.

hashfn
Funzione hash per il mapping delle chiavi ai bucket.

last
Fine dell'intervallo da inserire.

pred
Predicato di ordinamento per la sequenza controllata.

right
Oggetto o un intervallo da inserire.

Osservazioni:

Costruttore:

hash_multiset();

inizializza la sequenza controllata senza elementi, con il predicato key_compare()di ordinamento predefinito e con la funzione hash predefinita. Viene usato per specificare una sequenza controllata iniziale vuota, con il predicato di ordinamento predefinito e la funzione hash.

Costruttore:

explicit hash_multiset(key_compare^ pred);

inizializza la sequenza controllata senza elementi, con il predicato preddi ordinamento e con la funzione hash predefinita. Viene usato per specificare una sequenza controllata iniziale vuota, con il predicato di ordinamento specificato e la funzione hash predefinita.

Costruttore:

hash_multiset(key_compare^ pred, hasher^ hashfn);

inizializza la sequenza controllata senza elementi, con il predicato preddi ordinamento e con la funzione hashfnhash . Viene usato per specificare una sequenza controllata iniziale vuota, con il predicato di ordinamento e la funzione hash specificati.

Costruttore:

hash_multiset(hash_multiset<Key>% right);

inizializza la sequenza controllata con la sequenza [right.begin(), right.end()), con il predicato di ordinamento predefinito e con la funzione hash predefinita. Viene usato per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dall'oggetto hash_multiset right, con il predicato di ordinamento predefinito e la funzione hash.

Costruttore:

hash_multiset(hash_multiset<Key>^ right);

inizializza la sequenza controllata con la sequenza [right->begin(), right->end()), con il predicato di ordinamento predefinito e con la funzione hash predefinita. Viene usato per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dall'oggetto hash_multiset right, con il predicato di ordinamento predefinito e la funzione hash.

Costruttore:

template<typename InIter> hash_multiset(InIter first, InIter last);

inizializza la sequenza controllata con la sequenza [first, last), con il predicato di ordinamento predefinito e con la funzione hash predefinita. Viene usata per rendere la sequenza controllata una copia di un'altra sequenza, con il predicato di ordinamento predefinito e la funzione hash.

Costruttore:

template<typename InIter> hash_multiset(InIter first, InIter last, key_compare^ pred);

inizializza la sequenza controllata con la sequenza [first, last), con il predicato preddi ordinamento e con la funzione hash predefinita. Viene usato per creare la sequenza controllata una copia di un'altra sequenza, con il predicato di ordinamento specificato e la funzione hash predefinita.

Costruttore:

template<typename InIter> hash_multiset(InIter first, InIter last, key_compare^ pred, hasher^ hashfn);

inizializza la sequenza controllata con la sequenza [first, last), con il predicato preddi ordinamento e con la funzione hashfnhash . Viene usata per rendere la sequenza controllata una copia di un'altra sequenza, con il predicato di ordinamento e la funzione hash specificati.

Costruttore:

hash_multiset(System::Collections::Generic::IEnumerable<Key>^ right);

inizializza la sequenza controllata con la sequenza designata dall'enumeratore right, con il predicato di ordinamento predefinito e con la funzione hash predefinita. Viene usato per rendere la sequenza controllata una copia di un'altra sequenza descritta da un enumeratore, con il predicato di ordinamento predefinito e la funzione hash.

Costruttore:

hash_multiset(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred);

inizializza la sequenza controllata con la sequenza designata dall'enumeratore right, con il predicato preddi ordinamento e con la funzione hash predefinita. Viene usata per rendere la sequenza controllata una copia di un'altra sequenza descritta da un enumeratore, con il predicato di ordinamento specificato e la funzione hash predefinita.

Costruttore:

hash_multiset(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred, hasher^ hashfn);

inizializza la sequenza controllata con la sequenza designata dall'enumeratore right, con il predicato preddi ordinamento e con la funzione hashfnhash . Viene usato per creare la sequenza controllata una copia di un'altra sequenza descritta da un enumeratore, con il predicato di ordinamento e la funzione hash specificati.

Esempio

// cliext_hash_multiset_construct.cpp
// compile with: /clr
#include <cliext/hash_set>

int myfun(wchar_t key)
    { // hash a key
    return (key ^ 0xdeadbeef);
    }

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
// construct an empty container
    Myhash_multiset c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an ordering rule
    Myhash_multiset c2 = cliext::greater_equal<wchar_t>();
    System::Console::WriteLine("size() = {0}", c2.size());

    c2.insert(c1.begin(), c1.end());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an ordering rule and hash function
    Myhash_multiset c2h(cliext::greater_equal<wchar_t>(),
        gcnew Myhash_multiset::hasher(&myfun));
    System::Console::WriteLine("size() = {0}", c2h.size());

    c2h.insert(c1.begin(), c1.end());
    for each (wchar_t elem in c2h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an iterator range
    Myhash_multiset c3(c1.begin(), c1.end());
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule
    Myhash_multiset c4(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>());
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule and hash function
    Myhash_multiset c4h(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>(),
        gcnew Myhash_multiset::hasher(&myfun));
    for each (wchar_t elem in c4h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an enumeration
    Myhash_multiset c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
    for each (wchar_t elem in c5)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule
    Myhash_multiset c6(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3,
            cliext::greater_equal<wchar_t>());
    for each (wchar_t elem in c6)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule and hash function
    Myhash_multiset c6h(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3,
            cliext::greater_equal<wchar_t>(),
                gcnew Myhash_multiset::hasher(&myfun));
    for each (wchar_t elem in c6h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct from a generic container
    Myhash_multiset c7(c4);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    Myhash_multiset c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
a b c
size() = 0
a b c
size() = 0
c b a

a b c
a b c
c b a

a b c
a b c
c b a

a b c
a b c

`hash_multiset::hasher`

Delegato hash per una chiave.

Sintassi

Microsoft::VisualC::StlClr::UnaryDelegate<GKey, int>
    hasher;

Osservazioni:

Il tipo descrive un delegato che converte un valore di chiave in un numero intero.

Esempio

// cliext_hash_multiset_hasher.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::hasher^ myhash = c1.hash_delegate();

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }

hash(L'a') = 1616896120
hash(L'b') = 570892832

`hash_multiset::insert`

Aggiunge elementi.

Sintassi

iterator insert(value_type val);
iterator insert(iterator where, value_type val);
template<typename InIter>
    void insert(InIter first, InIter last);
void insert(System::Collections::Generic::IEnumerable<value_type>^ right);

Parametri

first
Inizio dell'intervallo da inserire.

last
Fine dell'intervallo da inserire.

right
Enumerazione da inserire.

val
Valore della chiave da inserire.

where
Dove nel contenitore inserire (solo hint).

Osservazioni:

Ognuna delle funzioni membro inserisce una sequenza specificata dagli operandi rimanenti.

La prima funzione membro inserisce un elemento con valore vale restituisce un iteratore che designa l'elemento appena inserito. Viene usato per inserire un singolo elemento.

La seconda funzione membro inserisce un elemento con valore val, usando where come hint (per migliorare le prestazioni) e restituisce un iteratore che designa l'elemento appena inserito. Viene usato per inserire un singolo elemento che potrebbe essere accanto a un elemento noto.

La terza funzione membro inserisce la sequenza [first, last). Viene usato per inserire zero o più elementi copiati da un'altra sequenza.

La quarta funzione membro inserisce la sequenza designata dall'oggetto right. Viene usato per inserire una sequenza descritta da un enumeratore.

Ogni inserimento di elementi richiede tempo proporzionale al logaritmo del numero di elementi nella sequenza controllata. L'inserimento può verificarsi in un tempo costante ammortizzato, tuttavia, dato un hint che designa un elemento accanto al punto di inserimento.

Esempio

// cliext_hash_multiset_insert.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value, unique and duplicate
    System::Console::WriteLine("insert(L'x') = {0}",
        *c1.insert(L'x'));

    System::Console::WriteLine("insert(L'b') = {0}",
        *c1.insert(L'b'));

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value with hint
    System::Console::WriteLine("insert(begin(), L'y') = {0}",
        *c1.insert(c1.begin(), L'y'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an iterator range
    Myhash_multiset c2;
    Myhash_multiset::iterator it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an enumeration
    Myhash_multiset c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
insert(L'x') = x
insert(L'b') = b
a b b c x
insert(begin(), L'y') = y
a b b c x y
a b b c x
a b b c x y

`hash_multiset::iterator`

Tipo di un iteratore per la sequenza controllata.

Sintassi

typedef T1 iterator;

Osservazioni:

Il tipo descrive un oggetto di tipo T1 non specificato che può fungere da iteratore bidirezionale per la sequenza controllata.

Esempio

// cliext_hash_multiset_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    Myhash_multiset::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }

a b c

`hash_multiset::key_comp`

Copia il delegato di ordinamento per due chiavi.

Sintassi

key_compare^key_comp();

Osservazioni:

La funzione membro restituisce il delegato di ordinamento utilizzato per ordinare la sequenza controllata. È possibile usarlo per confrontare due chiavi.

Esempio

// cliext_hash_multiset_key_comp.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Myhash_multiset c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

`hash_multiset::key_compare`

Delegato di ordinamento per due chiavi.

Sintassi

Microsoft::VisualC::StlClr::BinaryDelegate<GKey, GKey, bool>
    key_compare;

Osservazioni:

Il tipo è un sinonimo del delegato che determina l'ordinamento degli argomenti chiave.

Esempio

// cliext_hash_multiset_key_compare.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Myhash_multiset c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

`hash_multiset::key_type`

Tipo di una chiave di ordinamento.

Sintassi

typedef Key key_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Key.

Esempio

// cliext_hash_multiset_key_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" using key_type
    for (Myhash_multiset::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Myhash_multiset::key_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`hash_multiset::load_factor`

Conta il numero medio di elementi per bucket.

Sintassi

float load_factor();

Osservazioni:

La funzione membro restituisce(float)size() / count(). Viene usato per determinare le dimensioni medie del bucket.

Esempio

// cliext_hash_multiset_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

`hash_multiset::lower_bound`

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

Sintassi

iterator lower_bound(key_type key);

Parametri

key
Valore della chiave da cercare.

Osservazioni:

La funzione membro determina il primo elemento X nella sequenza controllata che esegue gli hash nello stesso bucket di key e ha un ordinamento equivalente a key. Se non esiste alcun elemento di questo tipo, restituisce end(); in caso contrario, restituisce un iteratore che designa X. Viene usato per individuare l'inizio di una sequenza di elementi attualmente nella sequenza controllata che corrispondono a una chiave specificata.

Esempio

// cliext_hash_multiset_lower_bound.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("lower_bound(L'x')==end() = {0}",
        c1.lower_bound(L'x') == c1.end());

    System::Console::WriteLine("*lower_bound(L'a') = {0}",
        *c1.lower_bound(L'a'));
    System::Console::WriteLine("*lower_bound(L'b') = {0}",
        *c1.lower_bound(L'b'));
    return (0);
    }

a b c
lower_bound(L'x')==end() = True
*lower_bound(L'a') = a
*lower_bound(L'b') = b

`hash_multiset::make_value`

Costruisce un oggetto valore.

Sintassi

static value_type make_value(key_type key);

Parametri

key
Valore della chiave da usare.

Osservazioni:

La funzione membro restituisce un value_type oggetto la cui chiave è key. È possibile usarlo per comporre un oggetto adatto per l'uso con diverse altre funzioni membro.

Esempio

// cliext_hash_multiset_make_value.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(Myhash_multiset::make_value(L'a'));
    c1.insert(Myhash_multiset::make_value(L'b'));
    c1.insert(Myhash_multiset::make_value(L'c'));

    // display contents " a b c"
    for each (Myhash_multiset::value_type elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c

`hash_multiset::max_load_factor`

Ottiene o imposta il numero massimo di elementi per bucket.

Sintassi

float max_load_factor();
void max_load_factor(float new_factor);

Parametri

new_factor
Nuovo fattore di carico massimo da archiviare.

Osservazioni:

La prima funzione membro restituisce il fattore di carico massimo archiviato corrente. Viene usato per determinare la dimensione media massima del bucket.

La seconda funzione membro sostituisce il fattore di carico massimo dell'archivio con new_factor. Non viene eseguito alcun rehashing automatico fino a quando non viene eseguito un inserimento successivo.

Esempio

// cliext_hash_multiset_max_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

`hash_multiset::operator=`

Sostituisce la sequenza controllata.

Sintassi

hash_multiset<Key>% operator=(hash_multiset<Key>% right);

Parametri

right
Contenitore da copiare.

Osservazioni:

L'operatore membro copia right nell'oggetto , quindi restituisce *this. Viene usato per sostituire la sequenza controllata con una copia della sequenza controllata in right.

Esempio

// cliext_hash_multiset_operator_as.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (Myhash_multiset::value_type elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    Myhash_multiset c2;
    c2 = c1;
// display contents " a b c"
    for each (Myhash_multiset::value_type elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c

`hash_multiset::rbegin`

Indica l'inizio della sequenza controllata inversa.

Sintassi

reverse_iterator rbegin();

Osservazioni:

La funzione membro restituisce un iteratore inverso che definisce l'ultimo elemento della sequenza controllata o appena oltre l'inizio di una sequenza vuota. Di conseguenza, designa l'oggetto beginning della sequenza inversa. Viene usato per ottenere un iteratore che definisce l'inizio current della sequenza controllata visualizzata in ordine inverso, ma il relativo stato può cambiare se la lunghezza della sequenza controllata cambia.

Esempio

// cliext_hash_multiset_rbegin.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Myhash_multiset::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);
    return (0);
    }

a b c
*rbegin() = c
*++rbegin() = b

`hash_multiset::reference`

Tipo di un riferimento a un elemento.

Sintassi

typedef value_type% reference;

Osservazioni:

Il tipo descrive un riferimento a un elemento.

Esempio

// cliext_hash_multiset_reference.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    Myhash_multiset::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Myhash_multiset::reference ref = *it;
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`hash_multiset::rehash`

Ricompila la tabella hash.

Sintassi

void rehash();

Osservazioni:

La funzione membro ricompila la tabella hash, assicurandosi che load_factor() <= max_load_factor(). In caso contrario, la tabella hash aumenta di dimensioni solo in base alle esigenze dopo un inserimento. Non diminuisce mai automaticamente le dimensioni. È possibile usarlo per regolare le dimensioni della tabella hash.

Esempio

// cliext_hash_multiset_rehash.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

`hash_multiset::rend`

Indica la fine della sequenza controllata inversa.

Sintassi

reverse_iterator rend();

Osservazioni:

La funzione membro restituisce un iteratore inverso che punta appena oltre l'inizio della sequenza controllata. Di conseguenza, designa l'oggetto end della sequenza inversa. Viene usato per ottenere un iteratore che designa la current fine della sequenza controllata visualizzata in ordine inverso, ma il relativo stato può cambiare se la lunghezza della sequenza controllata cambia.

Esempio

// cliext_hash_multiset_rend.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    Myhash_multiset::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);
    return (0);
    }

a b c
*-- --rend() = b
*--rend() = a

`hash_multiset::reverse_iterator`

Tipo di un iteratore inverso della sequenza controllata.

Sintassi

typedef T3 reverse_iterator;

Osservazioni:

Il tipo descrive un oggetto di tipo non specificato T3 che può essere utilizzato come iteratore inverso per la sequenza controllata.

Esempio

// cliext_hash_multiset_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" reversed
    Myhash_multiset::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }

c b a

`hash_multiset::size`

Conta il numero di elementi.

Sintassi

size_type size();

Osservazioni:

La funzione membro restituisce la lunghezza della sequenza controllata. Viene usato per determinare il numero di elementi attualmente presenti nella sequenza controllata. Se è importante sapere se la sequenza ha dimensioni diverse da zero, vedere hash_multiset::empty.

Esempio

// cliext_hash_multiset_size.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0} starting with 3", c1.size());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.insert(L'a');
    c1.insert(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2

`hash_multiset::size_type`

Tipo di una distanza Signed tra due elementi.

Sintassi

typedef int size_type;

Osservazioni:

Il tipo descrive un numero di elementi non negativi.

Esempio

// cliext_hash_multiset_size_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    Myhash_multiset::size_type diff = 0;
    for (Myhash_multiset::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3

`hash_multiset::swap`

Scambia il contenuto di due contenitori.

Sintassi

void swap(hash_multiset<Key>% right);

Parametri

right
Contenitore con cui scambiare il contenuto.

Osservazioni:

La funzione membro scambia le sequenze controllate tra this e right. Lo fa in tempo costante e non genera eccezioni. È possibile usarlo come modo rapido per scambiare il contenuto di due contenitori.

Esempio

// cliext_hash_multiset_swap.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct another container with repetition of values
    Myhash_multiset c2;
    c2.insert(L'd');
    c2.insert(L'e');
    c2.insert(L'f');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
d e f
d e f
a b c

`hash_multiset::to_array`

Copia la sequenza controllata in una nuova matrice.

Sintassi

cli::array<value_type>^ to_array();

Osservazioni:

La funzione membro restituisce una matrice contenente la sequenza controllata. Viene usato per ottenere una copia della sequenza controllata in formato matrice.

Esempio

// cliext_hash_multiset_to_array.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // copy the container and modify it
    cli::array<wchar_t>^ a1 = c1.to_array();

    c1.insert(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c d
a b c

`hash_multiset::upper_bound`

Trova la fine dell'intervallo che corrisponde a una chiave specificata.

Sintassi

iterator upper_bound(key_type key);

Parametri

key
Valore della chiave da cercare.

Osservazioni:

La funzione membro determina l'ultimo elemento X nella sequenza controllata che esegue gli hash nello stesso bucket di key e ha un ordinamento equivalente a key. Se non esiste alcun elemento di questo tipo o se X è l'ultimo elemento della sequenza controllata, restituisce end(); in caso contrario, restituisce un iteratore che designa il primo elemento oltre X. Viene usato per individuare la fine di una sequenza di elementi attualmente nella sequenza controllata che corrispondono a una chiave specificata.

Esempio

// cliext_hash_multiset_upper_bound.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("upper_bound(L'x')==end() = {0}",
        c1.upper_bound(L'x') == c1.end());

    System::Console::WriteLine("*upper_bound(L'a') = {0}",
        *c1.upper_bound(L'a'));
    System::Console::WriteLine("*upper_bound(L'b') = {0}",
        *c1.upper_bound(L'b'));
    return (0);
    }

a b c
upper_bound(L'x')==end() = True
*upper_bound(L'a') = b
*upper_bound(L'b') = c

`hash_multiset::value_comp`

Copia il delegato di ordinamento per due valori di elemento.

Sintassi

value_compare^ value_comp();

Osservazioni:

La funzione membro restituisce il delegato di ordinamento utilizzato per ordinare la sequenza controllata. Viene usato per confrontare due valori di elemento.

Esempio

// cliext_hash_multiset_value_comp.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();
    return (0);
    }

compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

`hash_multiset::value_compare`

Delegato di ordinamento per due valori di elemento.

Sintassi

Microsoft::VisualC::StlClr::BinaryDelegate<generic_value, generic_value, bool>
    value_compare;

Osservazioni:

Il tipo è un sinonimo del delegato che determina l'ordinamento dei relativi argomenti di valore.

Esempio

// cliext_hash_multiset_value_compare.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();
    return (0);
    }

compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

`hash_multiset::value_type`

Tipo di un elemento.

Sintassi

typedef generic_value value_type;

Osservazioni:

Il tipo è sinonimo di generic_value.

Esempio

// cliext_hash_multiset_value_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" using value_type
    for (Myhash_multiset::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Myhash_multiset::value_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

Condividi tramite

hash_multiset (STL/CLR)

Sintassi

Parametri

Requisiti

Dichiarazioni

Interfacce

Osservazioni:

Membri

hash_multiset::begin

Sintassi

Osservazioni:

Esempio

hash_multiset::bucket_count

Sintassi

Osservazioni:

Esempio

hash_multiset::clear

Sintassi

Osservazioni:

Esempio

hash_multiset::const_iterator

Sintassi

Osservazioni:

Esempio

hash_multiset::const_reference

Sintassi

Osservazioni:

Esempio

hash_multiset::const_reverse_iterator

Sintassi

Osservazioni:

Esempio

hash_multiset::count

Sintassi

Parametri

Osservazioni:

Esempio

hash_multiset::difference_type

Sintassi

Osservazioni:

Esempio

hash_multiset::empty

Sintassi

Osservazioni:

Esempio

hash_multiset::end

Sintassi

Osservazioni:

Esempio

hash_multiset::equal_range

Sintassi

Parametri

Osservazioni:

Esempio

hash_multiset::erase

Sintassi

Parametri

Osservazioni:

Esempio

hash_multiset::find

Sintassi

Parametri

Osservazioni:

Esempio

hash_multiset::generic_container

Sintassi

Osservazioni:

Esempio

hash_multiset::generic_iterator

Sintassi

Osservazioni:

Esempio

hash_multiset::generic_reverse_iterator

Sintassi

Osservazioni:

Esempio

hash_multiset::generic_value

Sintassi

Osservazioni:

`hash_multiset` (STL/CLR)

`hash_multiset::begin`

`hash_multiset::bucket_count`

`hash_multiset::clear`

`hash_multiset::const_iterator`

`hash_multiset::const_reference`

`hash_multiset::const_reverse_iterator`

`hash_multiset::count`

`hash_multiset::difference_type`

`hash_multiset::empty`

`hash_multiset::end`

`hash_multiset::equal_range`

`hash_multiset::erase`

`hash_multiset::find`

`hash_multiset::generic_container`

`hash_multiset::generic_iterator`

`hash_multiset::generic_reverse_iterator`

`hash_multiset::generic_value`

`hash_multiset::hash_delegate`

`hash_multiset::hash_multiset`

`hash_multiset::hasher`

`hash_multiset::insert`

`hash_multiset::iterator`

`hash_multiset::key_comp`

`hash_multiset::key_compare`

`hash_multiset::key_type`

`hash_multiset::load_factor`

`hash_multiset::lower_bound`

`hash_multiset::make_value`

`hash_multiset::max_load_factor`

`hash_multiset::operator=`

`hash_multiset::rbegin`

`hash_multiset::reference`

`hash_multiset::rehash`