`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. Il contenitore multiset viene usato per gestire una sequenza di elementi come albero ordinato (quasi) bilanciato di nodi, ognuno dei quali archivia un elemento.

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 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::ITree<Gkey, GValue>
    { ..... };

Parametri

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

Requisiti

Intestazione:<cliext/set>

Spazio dei nomicliext:

Dichiarazioni

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

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

Operatore	Descrizione
`multiset::operator=`	Sostituisce la sequenza controllata.
`operator!=` (multiset)	Determina se un `multiset` oggetto non è uguale a un altro `multiset` oggetto.
`operator<` (multiset)	Determina se un `multiset` oggetto è minore di un altro `multiset` oggetto.
`operator<=` (multiset)	Determina se un `multiset` oggetto è minore o uguale a un altro `multiset` oggetto.
`operator==` (multiset)	Determina se un `multiset` oggetto è uguale a un altro `multiset` oggetto.
`operator>` (multiset)	Determina se un `multiset` oggetto è maggiore di un altro `multiset` oggetto.
`operator>=` (multiset)	Determina se un `multiset` oggetto è maggiore o uguale a un altro `multiset` oggetto.

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.
`ITree<Key, Value>`	Gestire un contenitore generico.

Osservazioni:

L'oggetto alloca e libera l'archiviazione per la sequenza che controlla come singoli nodi. Inserisce gli elementi in un albero bilanciato (quasi) 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 la sequenza che controlla chiamando un oggetto delegato archiviato di tipo multiset::key_compare. È possibile specificare l'oggetto delegato archiviato quando si costruisce il multiset; se non si specifica alcun oggetto delegato, il valore predefinito è il confronto operator<(key_type, key_type). Per accedere a questo oggetto archiviato, chiamare la funzione multiset::key_compmembro .

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

Se key_comp()(X, Y) è true, X viene detto che deve essere ordinato prima Ydi .

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

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

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 logaritmico. Ovvero, il numero di operazioni è proporzionale al logaritmo del numero di elementi nella sequenza. 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.

Un 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 end(). È possibile decrementare questo iteratore per raggiungere l'ultimo elemento nella sequenza controllata, se presente. È possibile incrementare un 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 multiset elemento direttamente in base alla relativa posizione numerica. Questo richiede un iteratore ad accesso casuale.

Un multiset iteratore archivia un handle al nodo associato multiset , che a sua volta archivia un handle per il contenitore associato. È possibile usare gli iteratori solo con gli oggetti contenitore associati. Un multiset iteratore rimane valido fino a quando il nodo associato multiset è associato ad alcuni 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

`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_multiset_begin.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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
    Mymultiset::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

`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_multiset_clear.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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

`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_multiset_const_iterator.cpp
// compile with: /clr
#include <cliext/set>

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

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

a b c

`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_multiset_const_reference.cpp
// compile with: /clr
#include <cliext/set>

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

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

a b c

`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_multiset_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/set>

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

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

c b a

`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_multiset_count.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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

`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_multiset_difference_type.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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
    Mymultiset::difference_type diff = 0;
    for (Mymultiset::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (Mymultiset::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

`multiset::empty`

Verifica se sono presenti o meno degli elementi.

Sintassi

bool empty();

Osservazioni:

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

Esempio

// cliext_multiset_empty.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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

`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_multiset_end.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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
    Mymultiset::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

`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_multiset_equal_range.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
typedef Mymultiset::pair_iter_iter Pairii;
int main()
    {
    Mymultiset 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

`multiset::erase`

Rimuove gli elementi in corrispondenza delle posizioni specificate.

Sintassi

iterator erase(iterator where);
iterator erase(iterator first, iterator last);
size_type 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 definisce il primo elemento rimanente oltre qualsiasi elemento rimosso 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_multiset_erase.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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
    Mymultiset::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

`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_multiset_find.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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

`multiset::generic_container`

Tipo dell'interfaccia generica per il contenitore.

Sintassi

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

Osservazioni:

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

Esempio

// cliext_multiset_generic_container.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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
    Mymultiset::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

`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_multiset_generic_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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
    Mymultiset::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
    Mymultiset::generic_iterator gcit = gc1->begin();
    Mymultiset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
a

`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_multiset_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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
    Mymultiset::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
    Mymultiset::generic_reverse_iterator gcit = gc1->rbegin();
    Mymultiset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
c

`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_multiset_generic_value.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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
    Mymultiset::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
    Mymultiset::generic_iterator gcit = gc1->begin();
    Mymultiset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
a

`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_multiset_insert.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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
    Mymultiset c2;
    Mymultiset::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
    Mymultiset 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

`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_multiset_iterator.cpp
// compile with: /clr
#include <cliext/set>

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

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

a b c

`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_multiset_key_comp.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset c1;
    Mymultiset::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
    Mymultiset 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') = False
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

`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_multiset_key_compare.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset c1;
    Mymultiset::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
    Mymultiset 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') = False
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

`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_multiset_key_type.cpp
// compile with: /clr
#include <cliext/set>

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

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

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

a b c

`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 con 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_multiset_lower_bound.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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

`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_multiset_make_value.cpp
// compile with: /clr
#include <cliext/set>

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

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

a b c

`multiset::multiset`

Costruisce un oggetto contenitore.

Sintassi

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

Parametri

first
Inizio dell'intervallo da inserire.

last
Fine dell'intervallo da inserire.

pred
Predicato di ordinamento per la sequenza controllata.

right
Oggetto o un intervallo da inserire.

Osservazioni:

Costruttore:

multiset();

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

Costruttore:

explicit multiset(key_compare^ pred);

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

Costruttore:

multiset(multiset<Key>% right);

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

Costruttore:

multiset(multiset<Key>^ right);

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

Costruttore:

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

inizializza la sequenza controllata con la sequenza [first, last), con il predicato di ordinamento predefinito. Viene usato per creare la sequenza controllata una copia di un'altra sequenza, con il predicato di ordinamento predefinito.

Costruttore:

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

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

Costruttore:

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

inizializza la sequenza controllata con la sequenza designata dall'enumeratore right, con il predicato di ordinamento predefinito. È possibile usarla per rendere la sequenza controllata una copia di un'altra sequenza descritta da un enumeratore, con il predicato di ordinamento predefinito.

Costruttore:

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 . È possibile usarla per rendere la sequenza controllata una copia di un'altra sequenza descritta da un enumeratore, con il predicato di ordinamento specificato.

Esempio

// cliext_multiset_construct.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
// construct an empty container
    Mymultiset 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
    Mymultiset 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 iterator range
    Mymultiset 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
    Mymultiset 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 enumeration
    Mymultiset 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
    Mymultiset 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 from a generic container
    Mymultiset c7(c4);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    Mymultiset 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
c b a
a b c
c b a
a b c
c b a
c b a
a b c

`multiset::operator=`

Sostituisce la sequenza controllata.

Sintassi

multiset<Key>% operator=(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_multiset_operator_as.cpp
// compile with: /clr
#include <cliext/set>

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

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

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

a b c
a b c

`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_multiset_rbegin.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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
    Mymultiset::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

`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_multiset_reference.cpp
// compile with: /clr
#include <cliext/set>

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

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

a b c

`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_multiset_rend.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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
    Mymultiset::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

`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_multiset_reverse_iterator.cpp
// compile with: /clr
#include <cliext/set>

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

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

c b a

`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 empty().

Esempio

// cliext_multiset_size.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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

`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_multiset_size_type.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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
    Mymultiset::size_type diff = 0;
    for (Mymultiset::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

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

`multiset::swap`

Scambia il contenuto di due contenitori.

Sintassi

void swap(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_multiset_swap.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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
    Mymultiset 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

`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_multiset_to_array.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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

`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 con 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_multiset_upper_bound.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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

`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_multiset_value_comp.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset c1;
    Mymultiset::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') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

`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_multiset_value_compare.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset c1;
    Mymultiset::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') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

`multiset::value_type`

Tipo di un elemento.

Sintassi

typedef generic_value value_type;

Osservazioni:

Il tipo è sinonimo di generic_value.

Esempio

// cliext_multiset_value_type.cpp
// compile with: /clr
#include <cliext/set>

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

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

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

a b c

`operator!=` (multiset)

Confronto non uguale a quello dell'elenco.

Sintassi

template<typename Key>
    bool operator!=(multiset<Key>% left,
        multiset<Key>% right);

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce !(left == right). Viene usato per verificare se left non è ordinato come right quando i due multiset vengono confrontati in base all'elemento.

Esempio

// cliext_multiset_operator_ne.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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();

    // assign to a new container
    Mymultiset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

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

    System::Console::WriteLine("[a b c] != [a b c] is {0}",
        c1 != c1);
    System::Console::WriteLine("[a b c] != [a b d] is {0}",
        c1 != c2);
    return (0);
    }

a b c
a b d
[a b c] != [a b c] is False
[a b c] != [a b d] is True

`operator<` (multiset) (STL/CLR)

Elenco minore di confronto.

Sintassi

template<typename Key>
    bool operator<(multiset<Key>% left,
        multiset<Key>% right);

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione operatore restituisce true se, per la posizione i più bassa per la quale !(right[i] < left[i]) è true anche .left[i] < right[i] In caso contrario, viene restituito left->size() < right->size(). Viene usato per verificare se left viene ordinato prima right di quando i due multiset vengono confrontati in base all'elemento.

Esempio

// cliext_multiset_operator_lt.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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();

    // assign to a new container
    Mymultiset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

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

    System::Console::WriteLine("[a b c] < [a b c] is {0}",
        c1 < c1);
    System::Console::WriteLine("[a b c] < [a b d] is {0}",
        c1 < c2);
    return (0);
    }

a b c
a b d
[a b c] < [a b c] is False
[a b c] < [a b d] is True

`operator<=` (multiset)

Elencare un confronto minore o uguale.

Sintassi

template<typename Key>
    bool operator<=(multiset<Key>% left,
        multiset<Key>% right);

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce !(right < left). Viene usato per verificare se left non viene ordinato dopo right quando i due multiset vengono confrontati in base all'elemento.

Esempio

// cliext_multiset_operator_le.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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();

    // assign to a new container
    Mymultiset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

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

    System::Console::WriteLine("[a b c] <= [a b c] is {0}",
        c1 <= c1);
    System::Console::WriteLine("[a b d] <= [a b c] is {0}",
        c2 <= c1);
    return (0);
    }

a b c
a b d
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False

`operator==` (multiset)

Confronto di uguale elenco.

Sintassi

template<typename Key>
    bool operator==(multiset<Key>% left,
        multiset<Key>% right);

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce true solo se le sequenze controllate da left e right hanno la stessa lunghezza e, per ogni posizione i, left[i] == right[i]. Viene usato per verificare se left viene ordinato come right quando i due multiset vengono confrontati in base all'elemento.

Esempio

// cliext_multiset_operator_eq.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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();

    // assign to a new container
    Mymultiset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

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

    System::Console::WriteLine("[a b c] == [a b c] is {0}",
        c1 == c1);
    System::Console::WriteLine("[a b c] == [a b d] is {0}",
        c1 == c2);
    return (0);
    }

a b c
a b d
[a b c] == [a b c] is True
[a b c] == [a b d] is False

`operator>` (multiset)

Elenco maggiore del confronto.

Sintassi

template<typename Key>
    bool operator>(multiset<Key>% left,
        multiset<Key>% right);

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce right < left. Viene usato per verificare se left viene ordinato dopo right quando i due multiset vengono confrontati in base all'elemento.

Esempio

// cliext_multiset_operator_gt.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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();

    // assign to a new container
    Mymultiset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

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

    System::Console::WriteLine("[a b c] > [a b c] is {0}",
        c1 > c1);
    System::Console::WriteLine("[a b d] > [a b c] is {0}",
        c2 > c1);
    return (0);
    }

a b c
a b d
[a b c] > [a b c] is False
[a b d] > [a b c] is True

`operator>=` (multiset)

Elenco maggiore o uguale a confronto.

Sintassi

template<typename Key>
    bool operator>=(multiset<Key>% left,
        multiset<Key>% right);

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce !(left < right). Viene usato per verificare se left non è ordinato prima right quando i due multiset vengono confrontati in base all'elemento.

Esempio

// cliext_multiset_operator_ge.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::multiset<wchar_t> Mymultiset;
int main()
    {
    Mymultiset 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();

    // assign to a new container
    Mymultiset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

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

    System::Console::WriteLine("[a b c] >= [a b c] is {0}",
        c1 >= c1);
    System::Console::WriteLine("[a b c] >= [a b d] is {0}",
        c1 >= c2);
    return (0);
    }

a b c
a b d
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False

multiset (STL/CLR)

Sintassi

Parametri

Requisiti

Dichiarazioni

Interfacce

Osservazioni:

Membri

multiset::begin

Sintassi

Osservazioni:

Esempio

multiset::clear

Sintassi

Osservazioni:

Esempio

multiset::const_iterator

Sintassi

Osservazioni:

Esempio

multiset::const_reference

Sintassi

Osservazioni:

Esempio

multiset::const_reverse_iterator

Sintassi

Osservazioni:

Esempio

multiset::count

Sintassi

Parametri

Osservazioni:

Esempio

multiset::difference_type

Sintassi

Osservazioni:

Esempio

multiset::empty

Sintassi

Osservazioni:

Esempio

multiset::end

Sintassi

Osservazioni:

Esempio

multiset::equal_range

Sintassi

Parametri

Osservazioni:

Esempio

multiset::erase

Sintassi

Parametri

Osservazioni:

Esempio

multiset::find

Sintassi

Parametri

Osservazioni:

Esempio

multiset::generic_container

Sintassi

Osservazioni:

Esempio

multiset::generic_iterator

Sintassi

Osservazioni:

Esempio

multiset::generic_reverse_iterator

Sintassi

Osservazioni:

Esempio

multiset::generic_value

Sintassi

Osservazioni:

Esempio

multiset::insert

Sintassi

Parametri

Osservazioni:

`multiset` (STL/CLR)

`multiset::begin`

`multiset::clear`

`multiset::const_iterator`

`multiset::const_reference`

`multiset::const_reverse_iterator`

`multiset::count`

`multiset::difference_type`

`multiset::empty`

`multiset::end`

`multiset::equal_range`

`multiset::erase`

`multiset::find`

`multiset::generic_container`

`multiset::generic_iterator`

`multiset::generic_reverse_iterator`

`multiset::generic_value`

`multiset::insert`

`multiset::iterator`

`multiset::key_comp`

`multiset::key_compare`

`multiset::key_type`

`multiset::lower_bound`

`multiset::make_value`

`multiset::multiset`

`multiset::operator=`

`multiset::rbegin`

`multiset::reference`

`multiset::rend`

`multiset::reverse_iterator`

`multiset::size`

`multiset::size_type`

`multiset::swap`

`multiset::to_array`