Classe `multiset`

Articolo
10/12/2023

La classe multiset della libreria standard C++ viene usata per l'archiviazione e il recupero dei dati da una raccolta in cui i valori degli elementi contenuti non devono essere univoci e vengono usati come valori delle chiavi in base ai quali i dati sono ordinati automaticamente. Il valore della chiave di un elemento in un multiset oggetto potrebbe non essere modificato direttamente. È invece necessario eliminare i valori precedenti e inserire gli elementi che presentano nuovi valori.

Sintassi

template <class Key, class Compare =less <Key>, class Allocator =allocator <Key>>
class multiset

Parametri

Key
Tipo di dati degli elementi da archiviare in multiset.

Compare
Tipo che fornisce un oggetto funzione in grado di confrontare due valori di elemento come chiavi di ordinamento per determinare il relativo ordine nell'oggetto multiset. Il predicato binario minore<chiave> è il valore predefinito.

In C++14 è possibile abilitare la ricerca eterogenea specificando il std::less<> predicato o std::greater<> senza parametri di tipo. Per altre informazioni, vedere Ricerca eterogenea nei contenitori associativi .

Allocator
Tipo che rappresenta l'oggetto allocatore archiviato che incapsula i dettagli sull'allocazione multisete la deallocazione della memoria. Il valore predefinito è allocator<Key>.

Osservazioni:

La classe libreria multiset standard C++ è:

Un contenitore associativo, che è un contenitore di dimensioni variabili che supporta il recupero efficiente dei valori degli elementi in base a un valore della chiave associata.
Reversibile, in quanto fornisce iteratori bidirezionali per accedere ai relativi elementi.
Ordinato, poiché i relativi elementi sono ordinati in base ai valori delle chiavi all'interno del contenitore conformemente a una funzione di confronto specificata.
Più nel senso che i relativi elementi non devono avere chiavi univoce, in modo che un valore chiave possa avere molti valori di elemento associati.
Un contenitore associativo semplice, in quanto i valori dei relativi elementi corrispondono ai valori delle chiavi.
Un modello di classe, perché la funzionalità fornita è generica e quindi indipendente dal tipo specifico di dati contenuti come elementi. I tipi di dati da utilizzare sono invece specificati come parametro nel modello di classe insieme alla funzione di confronto e all'allocatore.

L'iteratore fornito dalla multiset classe è un iteratore bidirezionale, ma le funzioni insert membro della classe e multiset hanno versioni che accettano come parametri di modello un iteratore di input più debole, i cui requisiti di funzionalità sono più minimi di quelli garantiti dalla classe di iteratori bidirezionali. I diversi concetti di iteratore formano una famiglia correlata dai perfezionamenti delle relative funzionalità. Ogni concetto di iteratore dispone di un set di requisiti e gli algoritmi utilizzati con tali concetti devono limitare le proprie ipotesi ai requisiti forniti da tale tipo di iteratore. Si può presupporre che un iteratore di input possa essere dereferenziato per fare riferimento a un determinato oggetto e possa essere incrementato all'iteratore successivo nella sequenza. Si tratta di un set di funzionalità minimo, ma è sufficiente per poter descrivere chiaramente un intervallo di iteratori [ First, Last) nel contesto delle funzioni membro della classe.

La scelta del tipo di contenitore deve essere basata in genere sul tipo di ricerca e di inserimento richiesti dall'applicazione. I contenitori associativi sono ottimizzati per le operazioni di ricerca, inserimento e rimozione. Le funzioni membro che supportano in modo esplicito queste operazioni sono efficienti, eseguendole in un periodo medio proporzionale al logaritmo del numero di elementi nel contenitore. L'inserimento di elementi non invalida alcun iteratore e la rimozione di elementi invalida solo gli iteratori che avevano puntato agli elementi rimossi.

multiset Deve essere il contenitore associativo scelto quando le condizioni che associano i valori alle relative chiavi sono soddisfatte dall'applicazione. Gli elementi di un multiset oggetto possono essere multipli e fungono da chiavi di ordinamento proprie, quindi le chiavi non sono univoci. Un modello relativo a questo tipo di struttura è ad esempio un elenco ordinato di parole in cui tali parole possono essere presenti più volte. Se non sono consentite più occorrenze delle parole, la struttura di contenitore appropriata è rappresentata da un set. Se le definizioni univoche sono state allegate come valori all'elenco di parole chiave univoche, una mappa rappresenta una struttura appropriata per contenere questi dati. Se invece le definizioni non sono univoce, un multimap è il contenitore preferito.

Ordina multiset la sequenza che controlla chiamando un oggetto funzione archiviato di tipo Compare. Questo oggetto archiviato è una funzione di confronto accessibile chiamando la funzione key_compmembro . In generale, gli elementi devono essere semplicemente meno di paragonabili per stabilire questo ordine: in modo che, dato qualsiasi due elementi, possa essere determinato che sono equivalenti (nel senso che nessuno è minore dell'altro) o che uno è minore dell'altro. Di conseguenza, l'ordinamento viene eseguito tra gli elementi non equivalenti. A un livello più tecnico, la funzione di confronto è un predicato binario che provoca un ordinamento di tipo "strict weak" nel senso matematico standard. Un predicato binario f(x, y) è un oggetto funzione con due oggetti argomento x e y e un valore restituito di true o false. Un ordinamento imposto a un set è un ordinamento debole rigoroso se il predicato binario è irreflessivo, antisymmetrico e transitivo e se l'equivalenza è transitiva, dove due oggetti x e y vengono definiti come equivalenti quando entrambi f(x,y) e f(y,x) sono false. Se la condizione di uguaglianza più forte tra le chiavi sostituisce quella di equivalenza, l'ordinamento diventa totale, in quanto tutti gli elementi vengono ordinati l'uno rispetto all'altro e le chiavi accoppiate saranno indistinguibili l'una dall'altra.

Costruttori

Costruttore	Descrizione
multiset	Costruisce un `multiset` vuoto o che rappresenta una copia totale o parziale di un `multiset` specificato.

Typedef

Nome tipo	Descrizione
`allocator_type`	typedef per la classe `allocator` dell'oggetto `multiset`.
`const_iterator`	typedef per un iteratore bidirezionale in grado di leggere un elemento `const` nel `multiset`.
`const_pointer`	typedef per un puntatore a un elemento `const` di un `multiset`.
`const_reference`	Typedef per un riferimento a un `const` elemento archiviato in un `multiset` oggetto per la lettura e l'esecuzione di `const` operazioni.
`const_reverse_iterator`	typedef per un iteratore bidirezionale in grado di leggere qualsiasi elemento `const` nel `multiset`.
`difference_type`	typedef Signed Integer per il numero di elementi di un `multiset` in un intervallo compreso tra gli elementi a cui puntano gli iteratori.
`iterator`	typedef per un iteratore bidirezionale in grado di leggere o di modificare qualsiasi elemento di un `multiset`.
`key_compare`	typedef per un oggetto funzione in grado di confrontare due chiavi per determinare l'ordine relativo di due elementi nel `multiset`.
`key_type`	typedef per un oggetto funzione in grado di confrontare due chiavi di ordinamento per determinare l'ordine relativo di due elementi nel `multiset`.
`pointer`	typedef per un puntatore a un elemento di un `multiset`.
`reference`	typedef per un riferimento a un elemento archiviato in un `multiset`.
`reverse_iterator`	typedef per un iteratore bidirezionale in grado di leggere o di modificare un elemento di un `multiset` invertito.
`size_type`	Tipo Unsigned Integer in grado di rappresentare il numero di elementi di un `multiset`.
`value_compare`	typedef per un oggetto funzione in grado di confrontare due elementi come chiavi di ordinamento per determinarne l'ordine relativo nel `multiset`.
`value_type`	typedef che descrive un oggetto archiviato come elemento di un `multiset` in virtù della sua funzione di valore.

Funzioni membro

Funzione membro	Descrizione
`begin`	Restituisce un iteratore che punta al primo elemento del `multiset`.
`cbegin`	Restituisce un iteratore const che punta al primo elemento del `multiset`.
`cend`	Restituisce un iteratore const che punta alla posizione successiva all'ultimo elemento di un `multiset`.
`clear`	Cancella tutti gli elementi di un `multiset`.
`contains`^C++20	Controllare se è presente un elemento con la chiave specificata in `multiset`.
`count`	Restituisce il numero di elementi di un `multiset` la cui chiave corrisponde alla chiave specificata come parametro.
`crbegin`	Restituisce un iteratore const che punta al primo elemento di un `multiset` invertito.
`crend`	Restituisce un iteratore const che punta alla posizione successiva all'ultimo elemento di un set `multiset` invertito.
`emplace`	Inserisce un elemento costruito sul posto in un `multiset`.
`emplace_hint`	Inserisce un elemento costruito sul posto in un `multiset`, con un suggerimento sulla posizione.
`empty`	Verifica se un `multiset` è vuoto.
`end`	Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un `multiset`.
`equal_range`	Restituisce una coppia di iteratori. Il primo iteratore della coppia fa riferimento al primo elemento di un `multiset` con una chiave maggiore di una chiave specificata. Il secondo iteratore della coppia fa riferimento al primo elemento del `multiset` con una chiave uguale o maggiore della chiave specificata.
`erase`	Rimuove un elemento o un intervallo di elementi di un `multiset` dalle posizioni specificate oppure rimuove gli elementi che corrispondono a una chiave specificata.
`find`	Restituisce un iteratore che punta alla prima posizione di un elemento di un `multiset` con una chiave uguale a una chiave specificata.
`get_allocator`	Restituisce una copia dell'oggetto `allocator` utilizzato per costruire il `multiset`.
`insert`	Inserisce un elemento o un intervallo di elementi in un `multiset`.
`key_comp`	Fornisce un oggetto funzione in grado di confrontare due chiavi di ordinamento per determinare l'ordine relativo di due elementi nel `multiset`.
`lower_bound`	Restituisce un iteratore al primo elemento di un `multiset` con una chiave uguale o maggiore di una chiave specificata.
`max_size`	Restituisce la lunghezza massima del `multiset`.
`rbegin`	Restituisce un iteratore che punta al primo elemento di un `multiset` invertito.
`rend`	Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un `multiset` invertito.
`size`	Restituisce il numero di elementi di un `multiset`.
`swap`	Scambia gli elementi di due `multiset`.
`upper_bound`	Restituisce un iteratore al primo elemento di un `multiset` con una chiave maggiore di una chiave specificata.
`value_comp`	Recupera una copia dell'oggetto di confronto utilizzato per ordinare i valori degli elementi di un `multiset`.

Operatori

Operatore	Descrizione
`operator=`	Sostituisce gli elementi di un `multiset` con una copia di un altro `multiset`.

Requisiti

Intestazione:<set>

Spazio dei nomistd:

`multiset::allocator_type`

Tipo che rappresenta la classe allocatore per l'oggetto multiset

typedef Allocator allocator_type;

Osservazioni:

allocator_type è un sinonimo per il parametro di modello Allocator.

Per altre informazioni su Allocator, vedere la sezione Note dell'argomento Classe multiset.

Esempio

Vedere l'esempio per get_allocator un esempio di uso allocator_type

`multiset::begin`

Restituisce un iteratore che punta al primo elemento del multiset.

const_iterator begin() const;

iterator begin();

Valore restituito

Iteratore bidirezionale che punta al primo elemento nell'oggetto multiset o alla posizione successiva a un multiset vuoto.

Esempio

// multiset_begin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;
   multiset <int>::const_iterator ms1_cIter;

   ms1.insert( 1 );
   ms1.insert( 2 );
   ms1.insert( 3 );

   ms1_Iter = ms1.begin( );
   cout << "The first element of ms1 is " << *ms1_Iter << endl;

   ms1_Iter = ms1.begin( );
   ms1.erase( ms1_Iter );

   // The following 2 lines would err as the iterator is const
   // ms1_cIter = ms1.begin( );
   // ms1.erase( ms1_cIter );

   ms1_cIter = ms1.begin( );
   cout << "The first element of ms1 is now " << *ms1_cIter << endl;
}

The first element of ms1 is 1
The first element of ms1 is now 2

`multiset::cbegin`

Restituisce un iteratore const che punta al primo elemento dell'intervallo.

const_iterator cbegin() const;

Valore restituito

Iteratore di accesso bidirezionale const che punta al primo elemento dell'intervallo o alla posizione oltre la fine di un intervallo vuoto (per un intervallo vuoto, cbegin() == cend()).

Osservazioni:

Con il valore restituito di cbegin, gli elementi nell'intervallo non possono essere modificati.

È possibile usare questa funzione membro anziché la funzione membro begin() per garantire che il valore restituito sia const_iterator. In genere, viene usata insieme alla parola chiave di deduzione di tipo auto, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile di qualsiasi tipo che supporta begin() e cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`multiset::cend`

Restituisce un iteratore const che punta alla posizione oltre l'ultimo elemento di un intervallo.

const_iterator cend() const;

Valore restituito

Iteratore di accesso bidirezionale const che punta oltre la fine dell'intervallo.

Osservazioni:

cend viene utilizzato per verificare se un iteratore ha superato la fine del relativo intervallo.

È possibile usare questa funzione membro anziché la funzione membro end() per garantire che il valore restituito sia const_iterator. In genere, viene usata insieme alla parola chiave di deduzione di tipo auto, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile di qualsiasi tipo che supporta end() e cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

Il valore restituito da cend non deve essere dereferenziato.

`multiset::clear`

Cancella tutti gli elementi di un multiset.

void clear();

Esempio

// multiset_clear.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;

   ms1.insert( 1 );
   ms1.insert( 2 );

   cout << "The size of the multiset is initially "
        << ms1.size( ) << "." << endl;

   ms1.clear( );
   cout << "The size of the multiset after clearing is "
        << ms1.size( ) << "." << endl;
}

The size of the multiset is initially 2.
The size of the multiset after clearing is 0.

`multiset::const_iterator`

Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento const nel multiset.

typedef implementation-defined const_iterator;

Osservazioni:

Non è possibile usare un tipo const_iterator per modificare il valore di un elemento.

Esempio

Vedere l'esempio per begin un esempio che usa const_iterator.

`multiset::const_pointer`

Tipo che fornisce un puntatore a un elemento const in un multiset.

typedef typename allocator_type::const_pointer const_pointer;

Osservazioni:

Non è possibile usare un tipo const_pointer per modificare il valore di un elemento.

Nella maggior parte dei casi, è necessario usare un iteratore per accedere agli elementi in un multiset oggetto .

`multiset::const_reference`

Tipo che fornisce un riferimento a un const elemento archiviato in un multiset oggetto per la lettura e l'esecuzione di const operazioni.

typedef typename allocator_type::const_reference const_reference;

Esempio

// multiset_const_ref.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;

   ms1.insert( 10 );
   ms1.insert( 20 );

   // Declare and initialize a const_reference &Ref1
   // to the 1st element
   const int &Ref1 = *ms1.begin( );

   cout << "The first element in the multiset is "
        << Ref1 << "." << endl;

   // The following line would cause an error because the
   // const_reference can't be used to modify the multiset
   // Ref1 = Ref1 + 5;
}

The first element in the multiset is 10.

`multiset::const_reverse_iterator`

Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento const nel multiset.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Osservazioni:

Un tipo const_reverse_iterator non può modificare il valore di un elemento e viene usato per scorrere l'oggetto multiset inverso.

Esempio

Vedere l'esempio per rend un esempio di come dichiarare e usare .const_reverse_iterator

`multiset::contains`

Controllare se è presente un elemento con la chiave specificata in multiset.

bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;

Parametri

K
Tipo di chiave.

key
Valore della chiave dell'elemento da cercare.

Valore restituito

true se l'elemento viene trovato nel contenitore; false Altrimenti.

Osservazioni:

contains() è una novità di C++20. Per usarlo, specificare l'opzione del compilatore /std:c++20 o versione successiva.

template<class K> bool contains(const K& key) const partecipa alla risoluzione dell'overload solo se key_compare è trasparente. Per altre informazioni, vedere Ricerca eterogenea nei contenitori associativi .

Esempio

// Requires /std:c++20 or /std:c++latest
#include <set>
#include <iostream>

int main()
{
    std::multiset<int> theMultiSet = {1, 2};

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << theMultiSet.contains(2) << '\n';
    std::cout << theMultiSet.contains(3) << '\n';

    return 0;
}

true
false

`multiset::count`

Restituisce il numero di elementi di un multiset la cui chiave corrisponde a una chiave specificata dal parametro.

size_type count(const Key& key) const;

Parametri

key
Chiave degli elementi di cui trovare la corrispondenza dall'oggetto multiset.

Valore restituito

Numero di elementi nella multiset cui chiave di ordinamento corrisponde alla chiave del parametro.

Osservazioni:

La funzione membro restituisce il numero di elementi x nell'intervallo

[ lower_bound(key), upper_bound(key) )

Esempio

Nell'esempio seguente viene illustrato l'uso della multisetfunzione membro ::count.

// multiset_count.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
    using namespace std;
    multiset<int> ms1;
    multiset<int>::size_type i;

    ms1.insert(1);
    ms1.insert(1);
    ms1.insert(2);

    // Elements don't need to be unique in multiset,
    // so duplicates are allowed and counted.
    i = ms1.count(1);
    cout << "The number of elements in ms1 with a sort key of 1 is: "
         << i << "." << endl;

    i = ms1.count(2);
    cout << "The number of elements in ms1 with a sort key of 2 is: "
         << i << "." << endl;

    i = ms1.count(3);
    cout << "The number of elements in ms1 with a sort key of 3 is: "
         << i << "." << endl;
}

The number of elements in ms1 with a sort key of 1 is: 2.
The number of elements in ms1 with a sort key of 2 is: 1.
The number of elements in ms1 with a sort key of 3 is: 0.

`multiset::crbegin`

Restituisce un iteratore const che punta al primo elemento di un multiset invertito.

const_reverse_iterator crbegin() const;

Valore restituito

Iteratore bidirezionale const inverso che punta al primo elemento in un multiset invertito o che punta a quello che era stato l'ultimo elemento nel multiset non invertito.

Osservazioni:

crbegin viene usato con un multiset invertito esattamente come begin viene usato con un oggetto multiset.

Con il valore restituito di crbegin, l'oggetto multiset non può essere modificato.

crbegin può essere usato per eseguire l'iterazione all'indietro su un oggetto multiset.

Esempio

// multiset_crbegin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::const_reverse_iterator ms1_crIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_crIter = ms1.crbegin( );
   cout << "The first element in the reversed multiset is "
        << *ms1_crIter << "." << endl;
}

The first element in the reversed multiset is 30.

`multiset::crend`

Restituisce un iteratore const che punta alla posizione successiva all'ultimo elemento di un oggetto multiset invertito.

const_reverse_iterator crend() const;

Valore restituito

Iteratore bidirezionale const inverso che punta alla posizione successiva all'ultimo elemento di un oggetto multiset invertito, ovvero la posizione che precedeva il primo elemento dell'oggetto multiset non invertito.

Osservazioni:

crend viene usato con un multiset invertito esattamente come end viene usato con un oggetto multiset.

Con il valore restituito di crend, l'oggetto multiset non può essere modificato.

crend può essere usato per verificare se un iteratore inverso ha raggiunto la fine dell'oggetto multiset.

Il valore restituito da crend non deve essere dereferenziato.

Esempio

// multiset_crend.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main() {
   using namespace std;
   multiset <int> ms1;
   multiset <int>::const_reverse_iterator ms1_crIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_crIter = ms1.crend( ) ;
   ms1_crIter--;
   cout << "The last element in the reversed multiset is "
        << *ms1_crIter << "." << endl;
}

`multiset::difference_type`

Tipo Signed Integer che può essere utilizzato per rappresentare il numero di elementi di un multiset in un intervallo compreso tra gli elementi a cui puntano gli iteratori.

typedef typename allocator_type::difference_type difference_type;

Osservazioni:

difference_type è il tipo restituito quando si sottrae o si incrementa tramite gli iteratori del contenitore. difference_type viene in genere usato per rappresentare il numero di elementi nell'intervallo [ first, last) tra gli iteratori first e last, includendo l'elemento a cui punta first e l'intervallo di elementi fino all'elemento a cui punta last, escluso tale elemento.

Sebbene difference_type sia disponibile per tutti gli iteratori che soddisfano i requisiti di un iteratore di input, che include la classe di iteratori bidirezionali supportati da contenitori reversibili come set, la sottrazione tra iteratori è supportata solo dagli iteratori ad accesso casuale forniti da un contenitore ad accesso casuale come vettore.

Esempio

// multiset_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <set>
#include <algorithm>

int main( )
{
   using namespace std;

   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter, ms1_bIter, ms1_eIter;

   ms1.insert( 20 );
   ms1.insert( 10 );
   ms1.insert( 20 );

   ms1_bIter = ms1.begin( );
   ms1_eIter = ms1.end( );

   multiset <int>::difference_type   df_typ5, df_typ10, df_typ20;

   df_typ5 = count( ms1_bIter, ms1_eIter, 5 );
   df_typ10 = count( ms1_bIter, ms1_eIter, 10 );
   df_typ20 = count( ms1_bIter, ms1_eIter, 20 );

   // The keys, and hence the elements, of a multiset aren't unique
   cout << "The number '5' occurs " << df_typ5
        << " times in multiset ms1.\n";
   cout << "The number '10' occurs " << df_typ10
        << " times in multiset ms1.\n";
   cout << "The number '20' occurs " << df_typ20
        << " times in multiset ms1.\n";

   // Count the number of elements in a multiset
   multiset <int>::difference_type  df_count = 0;
   ms1_Iter = ms1.begin( );
   while ( ms1_Iter != ms1_eIter)
   {
      df_count++;
      ms1_Iter++;
   }

   cout << "The number of elements in the multiset ms1 is: "
        << df_count << "." << endl;
}

The number '5' occurs 0 times in multiset ms1.
The number '10' occurs 1 times in multiset ms1.
The number '20' occurs 2 times in multiset ms1.
The number of elements in the multiset ms1 is: 3.

`multiset::emplace`

Inserisce un elemento costruito in locale (senza che vengano eseguite operazioni di copia o di spostamento), con un suggerimento sulla posizione.

template <class... Args>
iterator emplace(Args&&... args);

Parametri

args
Argomenti inoltrati per costruire un elemento da inserire nell'oggetto multiset.

Valore restituito

Iteratore all'elemento appena inserito.

Osservazioni:

Questa funzione non invalida alcun riferimento a elementi del contenitore, ma potrebbe invalidare tutti gli iteratori per il contenitore.

Durante l'inserimento, se viene generata un'eccezione, lo stato del contenitore non viene modificato.

Esempio

// multiset_emplace.cpp
// compile with: /EHsc
#include <set>
#include <string>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: ";

    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    multiset<string> s1;

    s1.emplace("Anna");
    s1.emplace("Bob");
    s1.emplace("Carmine");

    cout << "multiset modified, now contains ";
    print(s1);
    cout << endl;

    s1.emplace("Bob");

    cout << "multiset modified, now contains ";
    print(s1);
    cout << endl;
}

`multiset::emplace_hint`

Inserisce un elemento costruito in locale (senza che vengano eseguite operazioni di copia o di spostamento), con un suggerimento sulla posizione.

template <class... Args>
iterator emplace_hint(
    const_iterator where,
    Args&&... args);

Parametri

args
Argomenti inoltrati per costruire un elemento da inserire nell'oggetto multiset.

where
Posizione in cui iniziare a cercare il punto di inserimento corretto. Se tale punto è immediatamente seguito da where, l'inserimento può avvenire in tempo costante ammortizzato anziché in tempo logaritmico.

Valore restituito

Iteratore all'elemento appena inserito.

Osservazioni:

Questa funzione non invalida alcun riferimento a elementi del contenitore, ma potrebbe invalidare tutti gli iteratori per il contenitore.

Durante l'inserimento, se viene generata un'eccezione, lo stato del contenitore non viene modificato.

Per un esempio di codice, vedere set::emplace_hint.

`multiset::empty`

Verifica se un multiset è vuoto.

bool empty() const;

Valore restituito

true se l'oggetto multiset è vuoto; false se l'oggetto multiset è non vuoto.

Esempio

// multiset_empty.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
   using namespace std;
   multiset <int> ms1, ms2;
   ms1.insert ( 1 );

   if ( ms1.empty( ) )
      cout << "The multiset ms1 is empty." << endl;
   else
      cout << "The multiset ms1 is not empty." << endl;

   if ( ms2.empty( ) )
      cout << "The multiset ms2 is empty." << endl;
   else
      cout << "The multiset ms2 is not empty." << endl;
}

The multiset ms1 is not empty.
The multiset ms2 is empty.

`multiset::end`

Restituisce l'iteratore successivo all'ultimo valore.

const_iterator end() const;

iterator end();

Valore restituito

Iteratore successivo all'ultimo valore. Se l'oggetto multiset è vuoto, multiset::end() == multiset::begin().

Osservazioni:

end viene usato per verificare se un iteratore ha superato la fine del relativo multiset.

Il valore restituito da end non deve essere dereferenziato.

Per un esempio di codice, vedere multiset::find.

`multiset::equal_range`

Restituisce una coppia di iteratori rispettivamente al primo elemento di un multiset con una chiave maggiore di una chiave specificata e al primo elemento di multiset con una chiave uguale o maggiore di tale chiave.

pair <const_iterator, const_iterator> equal_range (const Key& key) const;

pair <iterator, iterator> equal_range (const Key& key);

Parametri

key
Chiave dell'argomento multiset da confrontare con la chiave di ordinamento di un elemento dalla ricerca.

Valore restituito

Coppia di iteratori in modo che il primo sia la lower_bound chiave e la seconda sia la upper_bound chiave.

Per accedere al primo iteratore di una coppia pr restituita dalla funzione membro, usare pr. firste per dereferenziare l'iteratore con limite inferiore, usare *( pr. first). Per accedere al secondo iteratore di una coppia pr restituita dalla funzione membro, usare pr. seconde per dereferenziare l'iteratore superiore associato, usare *( pr. second).

Esempio

// multiset_equal_range.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   typedef multiset<int, less<int> > IntSet;
   IntSet ms1;
   multiset <int> :: const_iterator ms1_RcIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   pair <IntSet::const_iterator, IntSet::const_iterator> p1, p2;
   p1 = ms1.equal_range( 20 );

   cout << "The upper bound of the element with "
        << "a key of 20 in the multiset ms1 is: "
        << *( p1.second ) << "." << endl;

   cout << "The lower bound of the element with "
        << "a key of 20 in the multiset ms1 is: "
        << *( p1.first ) << "." << endl;

   // Compare the upper_bound called directly
   ms1_RcIter = ms1.upper_bound( 20 );
   cout << "A direct call of upper_bound( 20 ) gives "
        << *ms1_RcIter << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 20 )." << endl;

   p2 = ms1.equal_range( 40 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == ms1.end( ) ) && ( p2.second == ms1.end( ) ) )
      cout << "The multiset ms1 doesn't have an element "
              << "with a key less than 40." << endl;
   else
      cout << "The element of multiset ms1 with a key >= 40 is: "
                << *( p1.first ) << "." << endl;
}

The upper bound of the element with a key of 20 in the multiset ms1 is: 30.
The lower bound of the element with a key of 20 in the multiset ms1 is: 20.
A direct call of upper_bound( 20 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 20 ).
The multiset ms1 doesn't have an element with a key less than 40.

`multiset::erase`

Rimuove un elemento o un intervallo di elementi di un multiset dalle posizioni specificate oppure rimuove gli elementi che corrispondono a una chiave specificata.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parametri

Where
Posizione dell'elemento che deve essere rimosso.

First
Posizione del primo elemento che deve essere rimosso.

Last
Posizione immediatamente successiva all'ultimo elemento che deve essere rimosso.

key
Valore della chiave dell'elemento che deve essere rimosso.

Valore restituito

Per le prime due funzioni membro, un iteratore bidirezionale che definisce il primo elemento rimanente oltre gli elementi rimossi o un elemento che rappresenta la fine di multiset se tale elemento non esiste.

Per la terza funzione membro, restituisce il numero di elementi rimossi da multiset.

Osservazioni:

Per un esempio di codice, vedere set::erase.

`multiset::find`

Restituisce un iteratore che fa riferimento alla posizione di un elemento in un multiset oggetto con una chiave equivalente a una chiave specificata.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametri

key
Valore della chiave da trovare in base alla chiave di ordinamento di un elemento dall'oggetto di cui viene eseguita la multiset ricerca.

Valore restituito

Iteratore che fa riferimento alla posizione di un elemento con una chiave specificata o alla posizione successiva all'ultimo elemento in multiset ( multiset::end()) se non viene trovata alcuna corrispondenza per la chiave.

Osservazioni:

La funzione membro restituisce un iteratore che fa riferimento a un elemento nella multiset cui chiave è equivalente all'argomento key in un predicato binario che induce un ordinamento basato su una relazione di confronto minore di.

Se il valore restituito di find viene assegnato a un const_iteratoroggetto , l'oggetto multiset non può essere modificato. Se il valore restituito di find viene assegnato a un iteratoroggetto , l'oggetto multiset può essere modificato

Esempio

// compile with: /EHsc /W4 /MTd
#include <set>
#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename T> void print_elem(const T& t) {
    cout << "(" << t << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

template <typename C, class T> void findit(const C& c, T val) {
    cout << "Trying find() on value " << val << endl;
    auto result = c.find(val);
    if (result != c.end()) {
        cout << "Element found: "; print_elem(*result); cout << endl;
    } else {
        cout << "Element not found." << endl;
    }
}

int main()
{
    multiset<int> s1({ 40, 45 });
    cout << "The starting multiset s1 is: " << endl;
    print_collection(s1);

    vector<int> v;
    v.push_back(43);
    v.push_back(41);
    v.push_back(46);
    v.push_back(42);
    v.push_back(44);
    v.push_back(44); // attempt a duplicate

    cout << "Inserting the following vector data into s1: " << endl;
    print_collection(v);

    s1.insert(v.begin(), v.end());

    cout << "The modified multiset s1 is: " << endl;
    print_collection(s1);
    cout << endl;
    findit(s1, 45);
    findit(s1, 6);
}

`multiset::get_allocator`

Restituisce una copia dell'oggetto allocatore utilizzato per costruire l'oggetto multiset.

allocator_type get_allocator() const;

Valore restituito

Allocatore utilizzato dall'oggetto multiset.

Osservazioni:

Gli allocatori per la multiset classe specificano il modo in cui la classe gestisce l'archiviazione. Gli allocatori predefiniti acclusi alle classi contenitore della libreria standard C++ sono sufficienti per la maggior parte delle esigenze di programmazione. Scrivere e usare una classe allocator personalizzata è un argomento di C++ avanzato.

Esempio

// multiset_get_allocator.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int>::allocator_type ms1_Alloc;
   multiset <int>::allocator_type ms2_Alloc;
   multiset <double>::allocator_type ms3_Alloc;
   multiset <int>::allocator_type ms4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   multiset <int> ms1;
   multiset <int, allocator<int> > ms2;
   multiset <double, allocator<double> > ms3;

   cout << "The number of integers that can be allocated"
        << endl << "before free memory is exhausted: "
        << ms2.max_size( ) << "." << endl;

   cout << "The number of doubles that can be allocated"
        << endl << "before free memory is exhausted: "
        << ms3.max_size( ) <<  "." << endl;

   // The following lines create a multiset ms4
   // with the allocator of multiset ms1
   ms1_Alloc = ms1.get_allocator( );
   multiset <int> ms4( less<int>( ), ms1_Alloc );
   ms4_Alloc = ms4.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated with the other
   if( ms1_Alloc == ms4_Alloc )
   {
      cout << "Allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "Allocators are not interchangeable."
           << endl;
   }
}

`multiset::insert`

Inserisce un elemento o un intervallo di elementi in un multiset.

// (1) single element
pair<iterator, bool> insert(
    const value_type& Val);

// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
    ValTy&& Val);

// (3) single element with hint
iterator insert(
    const_iterator Where,
    const value_type& Val);

// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

// (5) range
template <class InputIterator>
void insert(
    InputIterator First,
    InputIterator Last);

// (6) initializer list
void insert(
    initializer_list<value_type>
IList);

Parametri

Val
Valore di un elemento da inserire nell'oggetto multiset.

Where
Posizione in cui iniziare a cercare il punto di inserimento corretto. Se tale punto è immediatamente seguito da Where, l'inserimento può avvenire in tempo costante ammortizzato anziché in tempo logaritmico.

ValTy
Parametro modello che specifica il tipo di argomento che l'oggetto multiset può usare per costruire un elemento di value_typee forward perfetti Val come argomento.

First
Posizione del primo elemento da copiare.

Last
Posizione immediatamente dopo l'ultimo elemento da copiare.

1
Argomento della funzione modello che soddisfa i requisiti di un oggetto input_iterator_tag che punta agli elementi di un tipo che possono essere utilizzati per costruire 1 oggetti.

IList
Oggetto initializer_list da cui copiare gli elementi.

Valore restituito

Le funzioni membro single-element-insert, (1) e (2), restituiscono un iteratore alla posizione in cui è stato inserito il nuovo elemento nell'oggetto multiset.

Le funzioni membro single-element-with-hint, (3) e (4), restituiscono un iteratore che punta alla posizione in cui è stato inserito il nuovo elemento nell'oggetto multiset.

Osservazioni:

Questa funzione non invalida alcun puntatore o riferimento, ma potrebbe invalidare tutti gli iteratori per il contenitore.

Durante l'inserimento di un solo elemento, se viene generata un'eccezione, lo stato del contenitore non viene modificato. Se viene generata un'eccezione durante l'inserimento di più elementi, il contenitore viene lasciato in uno stato non specificato ma comunque valido.

L'oggetto value_type di un contenitore è un typedef che appartiene al contenitore e, per set, multiset<V>::value_type è di tipo const V.

La funzione membro dell'intervallo (5) inserisce la sequenza di valori di elemento in un multiset oggetto che corrisponde a ogni elemento indirizzato da un iteratore nell'intervallo [First, Last), pertanto Last non viene inserito. La funzione membro di contenitore end() fa riferimento alla posizione immediatamente dopo l'ultimo elemento nel contenitore. L'istruzione s.insert(v.begin(), v.end());, ad esempio, cerca di inserire tutti gli elementi di v in s.

La funzione membro dell'elenco di inizializzatori (6) usa un oggetto initializer_list per copiare gli elementi in multiset.

Per l'inserimento di un elemento costruito sul posto, ovvero non vengono eseguite operazioni di copia o spostamento, vedere multiset::emplace e multiset::emplace_hint.

Esempio

// multiset_insert.cpp
// compile with: /EHsc
#include <set>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: ";

    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    // insert single values
    multiset<int> s1;
    // call insert(const value_type&) version
    s1.insert({ 1, 10 });
    // call insert(ValTy&&) version
    s1.insert(20);

    cout << "The original multiset values of s1 are:" << endl;
    print(s1);

    // intentionally attempt a duplicate, single element
    s1.insert(1);
    cout << "The modified multiset values of s1 are:" << endl;
    print(s1);
    cout << endl;

    // single element, with hint
    s1.insert(s1.end(), 30);
    cout << "The modified multiset values of s1 are:" << endl;
    print(s1);
    cout << endl;

    // The templatized version inserting a jumbled range
    multiset<int> s2;
    vector<int> v;
    v.push_back(43);
    v.push_back(294);
    v.push_back(41);
    v.push_back(330);
    v.push_back(42);
    v.push_back(45);

    cout << "Inserting the following vector data into s2:" << endl;
    print(v);

    s2.insert(v.begin(), v.end());

    cout << "The modified multiset values of s2 are:" << endl;
    print(s2);
    cout << endl;

    // The templatized versions move-constructing elements
    multiset<string>  s3;
    string str1("blue"), str2("green");

    // single element
    s3.insert(move(str1));
    cout << "After the first move insertion, s3 contains:" << endl;
    print(s3);

    // single element with hint
    s3.insert(s3.end(), move(str2));
    cout << "After the second move insertion, s3 contains:" << endl;
    print(s3);
    cout << endl;

    multiset<int> s4;
    // Insert the elements from an initializer_list
    s4.insert({ 4, 44, 2, 22, 3, 33, 1, 11, 5, 55 });
    cout << "After initializer_list insertion, s4 contains:" << endl;
    print(s4);
    cout << endl;
}

`multiset::iterator`

Tipo che fornisce un iteratore bidirezionale costante in grado di leggere qualsiasi elemento in un oggetto multiset.

typedef implementation-defined iterator;

Esempio

Vedere l'esempio per iniziare per un esempio di come dichiarare e usare un oggetto iterator.

`multiset::key_comp`

Recupera una copia dell'oggetto di confronto utilizzato per ordinare le chiavi di un multiset.

key_compare key_comp() const;

Valore restituito

Restituisce l'oggetto funzione utilizzato da un multiset oggetto per ordinare i relativi elementi, ovvero il parametro del modello Compare.

Per altre informazioni su Compare, vedere la sezione Note dell'argomento Classe multiset.

Osservazioni:

L'oggetto archiviato definisce la funzione membro:

bool operator( const Key&x, const Key&y);

che restituisce true se x precede rigorosamente y nell'ordinamento.

Entrambi key_compare e value_compare sono sinonimi per il parametro Comparedi modello . Entrambi i tipi vengono forniti per le classi impostate e multiset, in cui sono identiche, per compatibilità con le classi mappate e multimap, dove sono distinte.

Esempio

// multiset_key_comp.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;

   multiset <int, less<int> > ms1;
   multiset <int, less<int> >::key_compare kc1 = ms1.key_comp( ) ;
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true, "
           << "where kc1 is the function object of s1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of ms1."
           << endl;
   }

   multiset <int, greater<int> > ms2;
   multiset <int, greater<int> >::key_compare kc2 = ms2.key_comp( ) ;
   bool result2 = kc2( 2, 3 ) ;
   if( result2 == true )
   {
      cout << "kc2( 2,3 ) returns value of true, "
           << "where kc2 is the function object of ms2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of ms2."
           << endl;
   }
}

kc1( 2,3 ) returns value of true, where kc1 is the function object of s1.
kc2( 2,3 ) returns value of false, where kc2 is the function object of ms2.

`multiset::key_compare`

Tipo che fornisce un oggetto funzione in grado di confrontare due chiavi di ordinamento per determinare l'ordine relativo di due elementi nel multiset.

typedef Compare key_compare;

Osservazioni:

key_compare è un sinonimo per il parametro di modello Compare.

Per altre informazioni su Compare, vedere la sezione Osservazioni dell'argomento multiset Classe .

Esempio

Vedere l'esempio per key_comp un esempio di come dichiarare e usare key_compare.

`multiset::key_type`

Tipo che fornisce un oggetto funzione in grado di confrontare le chiavi di ordinamento per determinare l'ordine relativo di due elementi in multiset.

typedef Key key_type;

Osservazioni:

key_type è un sinonimo per il parametro di modello Key.

Per altre informazioni su Key, vedere la sezione Osservazioni dell'argomento multiset Classe .

Esempio

Vedere l'esempio per value_type un esempio di come dichiarare e usare key_type.

`multiset::lower_bound`

Restituisce un iteratore al primo elemento di un multiset con una chiave uguale o maggiore di una chiave specificata.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parametri

key
Chiave dell'argomento multiset da confrontare con la chiave di ordinamento di un elemento dalla ricerca.

Valore restituito

Oggetto iterator o const_iterator che punta alla posizione di un elemento in un multiset oggetto con una chiave uguale o maggiore della chiave dell'argomento oppure che punta alla posizione successiva all'ultimo elemento in multiset se non viene trovata alcuna corrispondenza per la chiave.

Esempio

// multiset_lower_bound.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int> :: const_iterator ms1_AcIter, ms1_RcIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_RcIter = ms1.lower_bound( 20 );
   cout << "The element of multiset ms1 with a key of 20 is: "
        << *ms1_RcIter << "." << endl;

   ms1_RcIter = ms1.lower_bound( 40 );

   // If no match is found for the key, end( ) is returned
   if ( ms1_RcIter == ms1.end( ) )
      cout << "The multiset ms1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of multiset ms1 with a key of 40 is: "
           << *ms1_RcIter << "." << endl;

   // The element at a specific location in the multiset can be
   // found using a dereferenced iterator addressing the location
   ms1_AcIter = ms1.end( );
   ms1_AcIter--;
   ms1_RcIter = ms1.lower_bound( *ms1_AcIter );
   cout << "The element of ms1 with a key matching "
        << "that of the last element is: "
        << *ms1_RcIter << "." << endl;
}

The element of multiset ms1 with a key of 20 is: 20.
The multiset ms1 doesn't have an element with a key of 40.
The element of ms1 with a key matching that of the last element is: 30.

`multiset::max_size`

Restituisce la lunghezza massima del multiset.

size_type max_size() const;

Valore restituito

Lunghezza massima possibile dell'oggetto multiset.

Esempio

// multiset_max_size.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::size_type i;

   i = ms1.max_size( );
   cout << "The maximum possible length "
        << "of the multiset is " << i << "." << endl;
}

`multiset::multiset`

Costruisce un multiset vuoto o che rappresenta una copia totale o parziale di un altro multiset.

multiset();

explicit multiset (
    const Compare& Comp);

multiset (
    const Compare& Comp,
    const Allocator& Al);

multiset(
    const multiset& Right);

multiset(
    multiset&& Right);

multiset(
    initializer_list<Type> IList);

multiset(
    initializer_list<Type> IList,
    const Compare& Comp);

multiset(
    initializer_list<Type> IList,
    const Compare& Comp,
    const Allocator& Al);

template <class InputIterator>
multiset (
    InputIterator First,
    InputIterator Last);

template <class InputIterator>
multiset (
    InputIterator First,
    InputIterator Last,
    const Compare& Comp);

template <class InputIterator>
multiset (
    InputIterator First,
    InputIterator Last,
    const Compare& Comp,
    const Allocator& Al);

Parametri

Al
Classe dell'allocatore di memoria da usare per l'oggetto multiset. Per impostazione predefinita è Allocator.

Comp
Funzione di confronto di tipo const Compare usata per ordinare gli elementi nell'oggetto multiset. Per impostazione predefinita è Compare.

Right
multiset di cui l'oggetto multiset costruito deve essere una copia.

First
Posizione del primo elemento nell'intervallo di elementi da copiare.

Last
Posizione del primo elemento oltre l'intervallo di elementi da copiare.

IList
Oggetto initializer_list da cui copiare gli elementi.

Osservazioni:

Tutti i costruttori archiviano un tipo di oggetto allocatore che gestisce l'archiviazione multiset di memoria per e che in un secondo momento può essere restituito chiamando get_allocator. Il parametro allocator viene spesso omesso nelle dichiarazioni di classe e vengono usate macro di pre-elaborazione per introdurre allocatori alternativi.

Tutti i costruttori inizializzano il relativo oggetto multiset.

Tutti i costruttori archiviano un oggetto funzione di tipo Compare utilizzato per stabilire un ordine tra le chiavi di multiset e che possono essere restituiti in un secondo momento chiamando key_comp.

I primi tre costruttori specificano un multiset iniziale vuoto, il secondo che specifica il tipo di funzione di confronto (Comp) da usare per stabilire l'ordine degli elementi e il terzo specifica in modo esplicito il tipo di allocatore (Al). La parola chiave explicit elimina alcuni tipi di conversione automatica del tipo.

Il quarto costruttore specifica una copia dell'oggetto multisetRight.

Il quinto costruttore specifica una copia dell'oggetto multiset spostando Right.

I costruttori 6, 7 e 8 specificano un initializer_list da cui copiare gli elementi.

I tre costruttori successivi copiano l'intervallo [First, Last) di un multiset oggetto con maggiore esplicitità specificando il tipo di funzione di confronto e l'allocatore.

Esempio

// multiset_ctor.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
    using namespace std;
    //multiset <int>::iterator ms1_Iter, ms2_Iter, ms3_Iter;
    multiset <int>::iterator ms4_Iter, ms5_Iter, ms6_Iter, ms7_Iter;

    // Create an empty multiset ms0 of key type integer
    multiset <int> ms0;

    // Create an empty multiset ms1 with the key comparison
    // function of less than, then insert 4 elements
    multiset <int, less<int> > ms1;
    ms1.insert(10);
    ms1.insert(20);
    ms1.insert(20);
    ms1.insert(40);

    // Create an empty multiset ms2 with the key comparison
    // function of greater than, then insert 2 elements
    multiset <int, less<int> > ms2;
    ms2.insert(10);
    ms2.insert(20);

    // Create a multiset ms3 with the
    // allocator of multiset ms1
    multiset <int>::allocator_type ms1_Alloc;
    ms1_Alloc = ms1.get_allocator();
    multiset <int> ms3(less<int>(), ms1_Alloc);
    ms3.insert(30);

    // Create a copy, multiset ms4, of multiset ms1
    multiset <int> ms4(ms1);

    // Create a multiset ms5 by copying the range ms1[ first,  last)
    multiset <int>::const_iterator ms1_bcIter, ms1_ecIter;
    ms1_bcIter = ms1.begin();
    ms1_ecIter = ms1.begin();
    ms1_ecIter++;
    ms1_ecIter++;
    multiset <int> ms5(ms1_bcIter, ms1_ecIter);

    // Create a multiset ms6 by copying the range ms4[ first,  last)
    // and with the allocator of multiset ms2
    multiset <int>::allocator_type ms2_Alloc;
    ms2_Alloc = ms2.get_allocator();
    multiset <int> ms6(ms4.begin(), ++ms4.begin(), less<int>(), ms2_Alloc);

    cout << "ms1 =";
    for (auto i : ms1)
        cout << " " << i;
    cout << endl;

    cout << "ms2 =";
    for (auto i : ms2)
        cout << " " << i;
   cout << endl;

   cout << "ms3 =";
   for (auto i : ms3)
       cout << " " << i;
    cout << endl;

    cout << "ms4 =";
    for (auto i : ms4)
        cout << " " << i;
    cout << endl;

    cout << "ms5 =";
    for (auto i : ms5)
        cout << " " << i;
    cout << endl;

    cout << "ms6 =";
    for (auto i : ms6)
        cout << " " << i;
    cout << endl;

    // Create a multiset by moving ms5
    multiset<int> ms7(move(ms5));
    cout << "ms7 =";
    for (auto i : ms7)
        cout << " " << i;
    cout << endl;

    // Create a multiset with an initializer_list
    multiset<int> ms8({1, 2, 3, 4});
    cout << "ms8=";
    for (auto i : ms8)
        cout << " " << i;
    cout << endl;
}

`multiset::operator=`

Sostituisce gli elementi di questo oggetto multiset usando gli elementi di un altro oggetto multiset.

multiset& operator=(const multiset& right);

multiset& operator=(multiset&& right);

Parametri

Right
Oggetto multiset da cui gli elementi vengono copiati o spostati.

Osservazioni:

operator= copia o sposta gli elementi di Right in questo oggetto multiset, a seconda del tipo di riferimento (lvalue o rvalue) usato. Gli elementi presenti in questo oggetto multiset prima dell'esecuzione di operator= vengono eliminati.

Esempio

// multiset_operator_as.cpp
// compile with: /EHsc
#include <multiset>
#include <iostream>

int main( )
   {
   using namespace std;
   multiset<int> v1, v2, v3;
   multiset<int>::iterator iter;

   v1.insert(10);

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << *iter << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;
   }

`multiset::pointer`

Tipo che fornisce un puntatore a un elemento in un multiset.

typedef typename allocator_type::pointer pointer;

Osservazioni:

È possibile utilizzare un tipo pointer per modificare il valore di un elemento.

Nella maggior parte dei casi, è necessario usare un iteratore per accedere agli elementi in un multiset oggetto .

`multiset::rbegin`

Restituisce un iteratore che punta al primo elemento di un multiset invertito.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valore restituito

Iteratore bidirezionale inverso che punta al primo elemento in un oggetto multiset invertito o che punta a ciò che era stato l'ultimo elemento nell'oggetto non invertito multiset.

Osservazioni:

rbegin viene usato con un oggetto invertito multiset proprio come rbegin viene usato con un oggetto multiset.

Se il valore restituito di rbegin viene assegnato a un const_reverse_iteratoroggetto , l'oggetto multiset non può essere modificato. Se il valore restituito di rbegin viene assegnato a un reverse_iteratoroggetto , l'oggetto multiset può essere modificato.

rbegin può essere usato per eseguire l'iterazione all'indietro su un oggetto multiset.

Esempio

// multiset_rbegin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;
   multiset <int>::reverse_iterator ms1_rIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_rIter = ms1.rbegin( );
   cout << "The first element in the reversed multiset is "
        << *ms1_rIter << "." << endl;

   // begin can be used to start an iteration
   // through a multiset in a forward order
   cout << "The multiset is:";
   for ( ms1_Iter = ms1.begin( ) ; ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << endl;

   // rbegin can be used to start an iteration
   // through a multiset in a reverse order
   cout << "The reversed multiset is:";
   for ( ms1_rIter = ms1.rbegin( ) ; ms1_rIter != ms1.rend( ); ms1_rIter++ )
      cout << " " << *ms1_rIter;
   cout << endl;

   // a multiset element can be erased by dereferencing to its key
   ms1_rIter = ms1.rbegin( );
   ms1.erase ( *ms1_rIter );

   ms1_rIter = ms1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed multiset is "<< *ms1_rIter << "."
        << endl;
}

The first element in the reversed multiset is 30.
The multiset is: 10 20 30
The reversed multiset is: 30 20 10
After the erasure, the first element in the reversed multiset is 20.

`multiset::reference`

Tipo che fornisce un riferimento a un elemento archiviato in un multiset.

typedef typename allocator_type::reference reference;

Esempio

// multiset_ref.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;

   ms1.insert( 10 );
   ms1.insert( 20 );

   // Declare and initialize a reference &Ref1 to the 1st element
   const int &Ref1 = *ms1.begin( );

   cout << "The first element in the multiset is "
        << Ref1 << "." << endl;
}

The first element in the multiset is 10.

`multiset::rend`

Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un multiset invertito.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valore restituito

Iteratore bidirezionale inverso che punta alla posizione successiva all'ultimo elemento di un oggetto invertito (la posizione che aveva preceduto multiset il primo elemento nell'oggetto non invertito multiset).

Osservazioni:

rend viene usato con un multiset invertito esattamente come end viene usato con un oggetto multiset.

Se il valore restituito di rend viene assegnato a un const_reverse_iteratoroggetto , l'oggetto multiset non può essere modificato. Se il valore restituito di rend viene assegnato a un reverse_iteratoroggetto , l'oggetto multiset può essere modificato.

rend può essere usato per verificare se un iteratore inverso ha raggiunto la fine del relativo oggetto multiset.

Il valore restituito da rend non deve essere dereferenziato.

Esempio

// multiset_rend.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main() {
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;
   multiset <int>::reverse_iterator ms1_rIter;
   multiset <int>::const_reverse_iterator ms1_crIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_rIter = ms1.rend( ) ;
   ms1_rIter--;
   cout << "The last element in the reversed multiset is "
        << *ms1_rIter << "." << endl;

   // end can be used to terminate an iteration
   // through a multiset in a forward order
   cout << "The multiset is: ";
   for ( ms1_Iter = ms1.begin( ) ; ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << *ms1_Iter << " ";
   cout << "." << endl;

   // rend can be used to terminate an iteration
   // through a multiset in a reverse order
   cout << "The reversed multiset is: ";
   for ( ms1_rIter = ms1.rbegin( ) ; ms1_rIter != ms1.rend( ); ms1_rIter++ )
      cout << *ms1_rIter << " ";
   cout << "." << endl;

   ms1_rIter = ms1.rend( );
   ms1_rIter--;
   ms1.erase ( *ms1_rIter );

   ms1_rIter = ms1.rend( );
   --ms1_rIter;
   cout << "After the erasure, the last element in the "
        << "reversed multiset is " << *ms1_rIter << "." << endl;
}

`multiset::reverse_iterator`

Tipo che fornisce un iteratore bidirezionale in grado di leggere o modificare un elemento di un oggetto multiset invertito.

typedef std::reverse_iterator<iterator> reverse_iterator;

Osservazioni:

Un tipo reverse_iterator viene usato per scorrere l'oggetto multiset inverso.

Esempio

Vedere l'esempio per rbegin un esempio di come dichiarare e usare reverse_iterator.

`multiset::size`

Restituisce il numero di elementi nel multiset.

size_type size() const;

Valore restituito

Lunghezza corrente dell'oggetto multiset.

Esempio

// multiset_size.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int> :: size_type i;

   ms1.insert( 1 );
   i = ms1.size( );
   cout << "The multiset length is " << i << "." << endl;

   ms1.insert( 2 );
   i = ms1.size( );
   cout << "The multiset length is now " << i << "." << endl;
}

The multiset length is 1.
The multiset length is now 2.

`multiset::size_type`

Tipo Unsigned Integer in grado di rappresentare il numero di elementi di un multiset.

typedef typename allocator_type::size_type size_type;

Esempio

Vedere l'esempio per size un esempio di come dichiarare e usare size_type

`multiset::swap`

Scambia gli elementi di due oggetti multiset.

void swap(
    multiset<Key, Compare, Allocator>& right);

Parametri

Right
Argomento di tipo multiset che fornisce gli elementi da scambiare con l'oggetto multiset di destinazione.

Osservazioni:

La funzione membro non invalida riferimenti, puntatori o iteratori che designano gli elementi dei due oggetti multiset di cui vengono scambiati gli elementi.

Esempio

// multiset_swap.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1, ms2, ms3;
   multiset <int>::iterator ms1_Iter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );
   ms2.insert( 100 );
   ms2.insert( 200 );
   ms3.insert( 300 );

   cout << "The original multiset ms1 is:";
   for ( ms1_Iter = ms1.begin( ); ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << "." << endl;

   // This is the member function version of swap
   ms1.swap( ms2 );

   cout << "After swapping with ms2, list ms1 is:";
   for ( ms1_Iter = ms1.begin( ); ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << "." << endl;

   // This is the specialized template version of swap
   swap( ms1, ms3 );

   cout << "After swapping with ms3, list ms1 is:";
   for ( ms1_Iter = ms1.begin( ); ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout   << "." << endl;
}

The original multiset ms1 is: 10 20 30.
After swapping with ms2, list ms1 is: 100 200.
After swapping with ms3, list ms1 is: 300.

`multiset::upper_bound`

Restituisce un iteratore al primo elemento di un multiset con una chiave maggiore di una chiave specificata.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parametri

key
Chiave dell'argomento multiset da confrontare con la chiave di ordinamento di un elemento dalla ricerca.

Valore restituito

Iteratore o const_iterator che punta alla posizione di un elemento in un multiset oggetto con una chiave maggiore della chiave dell'argomento o che punta alla posizione successiva all'ultimo elemento in multiset se non viene trovata alcuna corrispondenza per la chiave.

Esempio

// multiset_upper_bound.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int> :: const_iterator ms1_AcIter, ms1_RcIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_RcIter = ms1.upper_bound( 20 );
   cout << "The first element of multiset ms1 with a key greater "
           << "than 20 is: " << *ms1_RcIter << "." << endl;

   ms1_RcIter = ms1.upper_bound( 30 );

   // If no match is found for the key, end( ) is returned
   if ( ms1_RcIter == ms1.end( ) )
      cout << "The multiset ms1 doesn't have an element "
              << "with a key greater than 30." << endl;
   else
      cout << "The element of multiset ms1 with a key > 40 is: "
           << *ms1_RcIter << "." << endl;

   // The element at a specific location in the multiset can be
   // found using a dereferenced iterator addressing the location
   ms1_AcIter = ms1.begin( );
   ms1_RcIter = ms1.upper_bound( *ms1_AcIter );
   cout << "The first element of ms1 with a key greater than"
        << endl << "that of the initial element of ms1 is: "
        << *ms1_RcIter << "." << endl;
}

The first element of multiset ms1 with a key greater than 20 is: 30.
The multiset ms1 doesn't have an element with a key greater than 30.
The first element of ms1 with a key greater than
that of the initial element of ms1 is: 20.

`multiset::value_comp`

Recupera una copia dell'oggetto di confronto usato per ordinare i valori degli elementi di un multiset.

value_compare value_comp() const;

Valore restituito

Restituisce l'oggetto funzione utilizzato da un multiset oggetto per ordinare i relativi elementi, ovvero il parametro del modello Compare.

Per altre informazioni su Compare, vedere la sezione Osservazioni dell'argomento multiset Classe .

Osservazioni:

L'oggetto archiviato definisce la funzione membro:

bool operator( const Key&_xVal, const Key&_yVal);

che restituisce true se _xVal precede e non è uguale a _yVal nell'ordinamento.

Entrambi key_compare e value_compare sono sinonimi per il parametro Comparedi modello . Entrambi i tipi vengono forniti per le classi impostate e multiset, dove sono identiche, per compatibilità con le classi mappano e multimap, dove sono distinte.

Esempio

// multiset_value_comp.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;

   multiset <int, less<int> > ms1;
   multiset <int, less<int> >::value_compare vc1 = ms1.value_comp( );
   bool result1 = vc1( 2, 3 );
   if( result1 == true )
   {
      cout << "vc1( 2,3 ) returns value of true, "
           << "where vc1 is the function object of ms1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of ms1."
           << endl;
   }

   set <int, greater<int> > ms2;
   set<int, greater<int> >::value_compare vc2 = ms2.value_comp( );
   bool result2 = vc2( 2, 3 );
   if( result2 == true )
   {
      cout << "vc2( 2,3 ) returns value of true, "
           << "where vc2 is the function object of ms2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of ms2."
           << endl;
   }
}

vc1( 2,3 ) returns value of true, where vc1 is the function object of ms1.
vc2( 2,3 ) returns value of false, where vc2 is the function object of ms2.

`multiset::value_compare`

Tipo che fornisce un oggetto funzione in grado di confrontare due chiavi di ordinamento per determinare il relativo ordine nell'oggetto multiset.

typedef key_compare value_compare;

Osservazioni:

value_compare è un sinonimo per il parametro di modello Compare.

Per altre informazioni su Compare, vedere la sezione Note dell'argomento Classe multiset.

Esempio

Vedere l'esempio per value_comp un esempio di come dichiarare e usare value_compare.

`multiset::value_type`

Tipo che descrive un oggetto archiviato come elemento nella multiset sua capacità come valore.

typedef Key value_type;

Osservazioni:

value_type è un sinonimo per il parametro di modello Key.

Entrambi key_type e value_type sono sinonimi per il parametro Keydi modello . Entrambi i tipi vengono forniti per le classi impostate e multiset, in cui sono identiche, per compatibilità con le classi mappate e multimap, dove sono distinte.

Per altre informazioni su Key, vedere la sezione Note dell'argomento.

Esempio

// multiset_value_type.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;

   multiset <int> :: value_type svt_Int;   // Declare value_type
   svt_Int = 10;             // Initialize value_type

   multiset <int> :: key_type skt_Int;   // Declare key_type
   skt_Int = 20;             // Initialize key_type

   ms1.insert( svt_Int );         // Insert value into s1
   ms1.insert( skt_Int );         // Insert key into s1

   // a multiset accepts key_types or value_types as elements
   cout << "The multiset has elements:";
   for ( ms1_Iter = ms1.begin( ) ; ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << "." << endl;
}

The multiset has elements: 10 20.

Vedi anche

Contenitori
Thread Safety in the C++ Standard Library (Sicurezza dei thread nella libreria standard C++)
Informazioni di riferimento per la libreria standard C++

Share via

Classe multiset

Sintassi

Parametri

Osservazioni:

Costruttori

Typedef

Funzioni membro

Operatori

Requisiti

multiset::allocator_type

Osservazioni:

Esempio

multiset::begin

Valore restituito

Esempio

multiset::cbegin

Valore restituito

Osservazioni:

multiset::cend

Valore restituito

Osservazioni:

multiset::clear

Esempio

multiset::const_iterator

Osservazioni:

Esempio

multiset::const_pointer

Osservazioni:

multiset::const_reference

Esempio

multiset::const_reverse_iterator

Osservazioni:

Esempio

multiset::contains

Parametri

Valore restituito

Osservazioni:

Esempio

multiset::count

Parametri

Valore restituito

Osservazioni:

Esempio

multiset::crbegin

Valore restituito

Osservazioni:

Esempio

multiset::crend

Valore restituito

Osservazioni:

Esempio

multiset::difference_type

Osservazioni:

Esempio

multiset::emplace

Parametri

Valore restituito

Osservazioni:

Esempio

multiset::emplace_hint

Parametri

Valore restituito

Osservazioni:

multiset::empty

Valore restituito

Esempio

multiset::end

Valore restituito

Osservazioni:

multiset::equal_range

Parametri

Valore restituito

Esempio

multiset::erase

Parametri

Valore restituito

Osservazioni:

multiset::find

Parametri

Classe `multiset`

`multiset::allocator_type`

`multiset::begin`

`multiset::cbegin`

`multiset::cend`

`multiset::clear`

`multiset::const_iterator`

`multiset::const_pointer`

`multiset::const_reference`

`multiset::const_reverse_iterator`

`multiset::contains`

`multiset::count`

`multiset::crbegin`

`multiset::crend`

`multiset::difference_type`

`multiset::emplace`

`multiset::emplace_hint`

`multiset::empty`

`multiset::end`

`multiset::equal_range`

`multiset::erase`

`multiset::find`

`multiset::get_allocator`

`multiset::insert`

`multiset::iterator`

`multiset::key_comp`

`multiset::key_compare`

`multiset::key_type`

`multiset::lower_bound`

`multiset::max_size`

`multiset::multiset`

`multiset::operator=`

`multiset::pointer`

`multiset::rbegin`

`multiset::reference`

`multiset::rend`

`multiset::reverse_iterator`

`multiset::size`

`multiset::size_type`

`multiset::swap`

`multiset::upper_bound`

`multiset::value_comp`