Classe hash_multiset

Articolo
10/12/2023

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

La classe contenitore hash_multiset è un'estensione della libreria standard C++ e viene usata per l'archiviazione e il recupero veloce dei dati da una raccolta in cui i valori degli elementi contenuti vengono usati come valori delle chiavi e non devono essere necessariamente univoci.

Sintassi

template <class Key, class Traits =hash_compare<Key, less <Key>>, class Allocator =allocator <Key>>
class hash_multiset

Parametri

Chiave
Tipo di dati degli elementi da archiviare in hash_multiset.

Tratti
Tipo che include due oggetti funzione, uno della classe compare che è un predicato binario in grado di confrontare due valori di elemento come chiavi di ordinamento per determinare l'ordine relativo e una funzione hash che è un predicato unario che esegue il mapping dei valori chiave degli elementi a interi senza segno di tipo size_t. Questo argomento è facoltativo e il valore predefinito è hash_compare<Key, less<Key> >.

Allocatore
Tipo che rappresenta l'oggetto allocatore archiviato che incapsula i dettagli relativi all'allocazione dell'hash_multiset e alla deallocazione della memoria. Questo argomento è facoltativo e il valore predefinito è allocator<Key>.

Osservazioni:

L'hash_multiset è:

Un contenitore associativo, che è un contenitore di dimensioni variabili che supporta il recupero efficiente dei valori degli elementi in base al valore di una chiave associata. È inoltre un contenitore associativo semplice, in quanto i valori dei relativi elementi corrispondono ai valori delle chiavi.
Reversibile, in quanto fornisce un iteratore bidirezionale per accedere ai relativi elementi.
Con hash, poiché i rispettivi elementi sono raggruppati in bucket in base al valore di una funzione hash applicata ai valori di chiave degli elementi.
Univoco nel senso che ogni elemento deve disporre di una chiave univoca. Poiché hash_multiset è anche un contenitore associativo semplice, anche i relativi elementi sono univoci.
Un modello di classe perché la funzionalità fornita è generica e quindi indipendente dal tipo specifico di dati contenuti come elementi o chiavi. I tipi di dati da utilizzare per gli elementi e le chiavi vengono invece specificati come parametri nel modello di classe i insieme alla funzione di confronto e all'allocatore.

Il vantaggio principale dell'hashing rispetto all'ordinamento è costituito da una maggiore efficienza. Un hashing corretto esegue inserimenti, eliminazioni e ricerche in un tempo medio costante rispetto al tempo proporzionale al logaritmo del numero di elementi nel contenitore per le tecniche di ordinamento. Non è possibile modificare direttamente il valore di un elemento di un set. È invece necessario eliminare i valori precedenti e inserire gli elementi che presentano nuovi valori.

La scelta del tipo di contenitore deve essere basata in genere sul tipo di ricerca e di inserimento richiesti dall'applicazione. I contenitori associativi con hash sono ottimizzati per le operazioni di ricerca, inserimento e rimozione. Le funzioni membro che supportano in modo esplicito queste operazioni risultano efficienti quando vengono usate con una funzione hash ben progettata, poiché eseguono le operazioni in un tempo mediamente costante e non dipendente dal numero di elementi nel contenitore. Una funzione hash ben progettata produce una distribuzione uniforme di valori con hash e riduce al minimo i numeri di conflitti. Un conflitto si verifica quando viene eseguito il mapping di valori di chiave distinti allo stesso valore con hash. Nella peggiore delle ipotesi, con la peggiore funzione hash possibile, il numero di operazioni è proporzionale al numero di elementi della sequenza (tempo lineare).

L'hash_multiset deve essere il contenitore associativo da preferire quando le condizioni che consentono di associare i valori alle relative chiavi vengono soddisfatte dall'applicazione. Un hash_multiset può contenere più elementi che possono essere usati come chiavi di ordinamento, pertanto le chiavi non sono univoche. 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 hash_multiset. Se le definizioni univoche sono state allegate come valori all'elenco di parole chiave univoche, un hash_map rappresenta una struttura appropriata per contenere questi dati. Se invece le definizioni non sono univoche, è opportuno scegliere come contenitore un hash_multimap.

L'oggetto hash_multiset ordina la sequenza che controlla chiamando un oggetto di tratti hash archiviato di tipo value_compare. È possibile accedere a questo oggetto archiviato chiamando la funzione membro key_comp. Un oggetto funzione di questo tipo deve comportarsi come un oggetto della classe hash_compare<Key, less<Key> >. In particolare, per tutti i valori Chiave di tipo Key, la chiamata Trait(Key) restituisce una distribuzione di valori di tipo size_t .

In genere, gli elementi devono essere confrontabili come "minore di" per stabilire questo ordine: in modo che, dati qualsiasi due elementi, sia possibile determinare che sono equivalenti (ovvero che uno non è 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 che dispone di due oggetti argomento x e y e di un valore restituito true o false. Un ordinamento imposto a un oggetto hash_multiset è un ordinamento di tipo "strict weak" se il predicato binario è irriflessivo, antisimmetrico e transitivo e se l'equivalenza è transitiva, in cui due oggetti x e y vengono definiti equivalenti quando sia f( x, y) che 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.

L'ordine effettivo degli elementi nella sequenza controllata dipende dalla funzione hash, dalla funzione di ordinamento e dalle dimensioni correnti della tabella hash archiviata nell'oggetto contenitore. Non è possibile determinare le dimensioni correnti della tabella hash, quindi non è in genere possibile prevedere l'ordine degli elementi nella sequenza selezionata. L'inserimento di elementi non invalida gli iteratori e la rimozione di tali elementi invalida solo gli iteratori che avevano puntato in modo specifico agli elementi rimossi.

L'iteratore fornito dalla classe hash_multiset è un iteratore bidirezionale, ma le funzioni membro insert e hash_multiset della classe hanno versioni che accettano come parametri di modello un iteratore di input più debole, in cui i requisiti delle funzionalità sono inferiori a quelli garantiti dalla classe degli iteratori bidirezionali. I diversi concetti di iteratore formano una famiglia correlata dai perfezionamenti delle relative funzionalità. Ogni concetto di iteratore ha un proprio hash_multiset di requisiti e gli algoritmi usati con tali concetti devono limitare i propri presupposti 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 hash_multiset di funzionalità minimo, ma è sufficiente per poter descrivere chiaramente un intervallo di iteratori (first, last) nel contesto delle funzioni membro della classe.

Costruttori

Costruttore	Descrizione
hash_multiset	Costruisce un `hash_multiset` vuoto o che rappresenta una copia totale o parziale di un altro `hash_multiset`.

Typedef

Nome tipo	Descrizione
allocator_type	Tipo che rappresenta la classe `allocator` per l'oggetto `hash_multiset`.
const_iterator	Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento `const` nel `hash_multiset`.
const_pointer	Tipo che fornisce un puntatore a un elemento `const` in un `hash_multiset`.
const_reference	Tipo che fornisce un riferimento a un elemento `const` archiviato in un `hash_multiset` per la lettura e l'esecuzione di operazioni `const`.
const_reverse_iterator	Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento `const` nel `hash_multiset`.
difference_type	Tipo Signed Integer che specifica la differenza tra due iteratori che puntano a elementi all'interno dello stesso `hash_multiset`.
iterator	Tipo che fornisce un iteratore bidirezionale in grado di leggere o modificare qualsiasi elemento di un `hash_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 `hash_multiset`.
key_type	Tipo che descrive un oggetto archiviato come elemento di un `hash_set` grazie alla relativa funzione di chiave di ordinamento.
pointer	Tipo che fornisce un puntatore a un elemento in un `hash_multiset`.
reference	Tipo che fornisce un riferimento a un elemento archiviato in un `hash_multiset`.
reverse_iterator	Tipo che fornisce un iteratore bidirezionale in grado di leggere o modificare un elemento di un `hash_multiset` invertito.
size_type	Tipo Unsigned Integer in grado di rappresentare il numero di elementi di un `hash_multiset`.
value_compare	Tipo che fornisce due oggetti funzione, un predicato binario della classe compare in grado di confrontare due valori di elemento di un `hash_multiset` per determinarne l'ordine relativo e un predicato unario che genera un hash per gli elementi.
value_type	Tipo che descrive un oggetto archiviato come elemento di un `hash_multiset` grazie alla relativa funzione di un valore.

Funzioni membro

Funzione membro	Descrizione
begin	Restituisce un iteratore che punta al primo elemento in `hash_multiset`.
cbegin	Restituisce un iteratore const che punta al primo elemento del `hash_multiset`.
cend	Restituisce un iteratore const che punta alla posizione successiva all'ultimo elemento di un `hash_multiset`.
deselezionare	Cancella tutti gli elementi di un `hash_multiset`.
count	Restituisce il numero di elementi di un `hash_multiset` la cui chiave corrisponde a una chiave specificata dal parametro
crbegin	Restituisce un iteratore const che punta al primo elemento di un `hash_multiset` invertito.
crend	Restituisce un iteratore const che punta alla posizione successiva all'ultimo elemento di un set `hash_multiset` invertito.
emplace	Inserisce un elemento costruito sul posto in un `hash_multiset`.
emplace_hint	Inserisce un elemento costruito sul posto in un `hash_multiset`, con un suggerimento sulla posizione.
empty	Verifica se un `hash_multiset` è vuoto.
end	Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un `hash_multiset`.
equal_range	Restituisce una coppia di iteratori rispettivamente al primo elemento di un `hash_multiset` con una chiave maggiore di una chiave specificata e al primo elemento di `hash_multiset` con una chiave uguale o maggiore di tale chiave.
erase	Rimuove un elemento o un intervallo di elementi di un `hash_multiset` dalle posizioni specificate oppure rimuove gli elementi che corrispondono a una chiave specificata.
find	Restituisce un iteratore che punta alla posizione di un elemento in un `hash_multiset` che dispone di una chiave equivalente a una chiave specificata.
get_allocator	Restituisce una copia dell'oggetto `allocator` utilizzato per costruire il `hash_multiset`.
insert	Inserisce un elemento o un intervallo di elementi in un `hash_multiset`.
key_comp	Recupera una copia dell'oggetto di confronto utilizzato per ordinare le chiavi di un `hash_multiset`.
lower_bound	Restituisce un iteratore al primo elemento di un `hash_multiset` con una chiave uguale o maggiore di una chiave specificata.
max_size	Restituisce la lunghezza massima del `hash_multiset`.
rbegin	Restituisce un iteratore che punta al primo elemento di un `hash_multiset` invertito.
rend	Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un `hash_multiset` invertito.
size	Restituisce il numero di elementi nel `hash_multiset`.
swap	Scambia gli elementi di due `hash_multiset`.
upper_bound	Restituisce un iteratore al primo elemento di un `hash_multiset` con una chiave uguale o maggiore di una chiave specificata.
value_comp	Recupera una copia dell'oggetto dei tratti hash usato per generare un hash e ordinare i valori delle chiavi dell'elemento in un `hash_multiset`.

Operatori

Operatore	Descrizione
hash_multiset::operator=	Sostituisce gli elementi dell'oggetto hash_multiset con una copia di un altro oggetto hash_multiset.

Requisiti

Intestazione:<hash_set>

Spazio dei nomi: stdext

hash_multiset::allocator_type

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Tipo che rappresenta la classe allocator per l'oggetto hash_multiset.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::allocator_type allocator_type;

Esempio

Vedere l'esempio relativo a get_allocator per indicazioni su come usare allocator_type.

hash_multiset::begin

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Restituisce un iteratore che punta al primo elemento dell'oggetto hash_multiset.

const_iterator begin() const;

iterator begin();

Valore restituito

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

Osservazioni:

Se il valore restituito di begin viene assegnato a un const_iteratoroggetto , gli elementi nell'oggetto hash_multiset non possono essere modificati. Se il valore restituito di begin viene assegnato a un iteratoroggetto , è possibile modificare gli elementi nell'oggetto hash_multiset.

Esempio

// hash_multiset_begin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter;
   hash_multiset <int>::const_iterator hms1_cIter;

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

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

   hms1_Iter = hms1.begin( );
   hms1.erase( hms1_Iter );

   // The following 2 lines would err because the iterator is const
   // hms1_cIter = hms1.begin( );
   // hms1.erase( hms1_cIter );

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

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

hash_multiset::cbegin

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

const_iterator cbegin() const;

Valore restituito

Iteratore bidirezionale const che punta al primo elemento dell'oggetto hash_multiset o alla posizione successiva a un oggetto hash_multiset vuoto.

Osservazioni:

Con il valore restituito di cbegin, gli elementi dell'oggetto hash_multiset non possono essere modificati.

Esempio

// hash_multiset_cbegin.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hs1;
   hash_multiset <int>::const_iterator hs1_cIter;

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

   hs1_cIter = hs1.cbegin( );
   cout << "The first element of hs1 is " << *hs1_cIter << endl;
}

The first element of hs1 is 1

hash_multiset::cend

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

const_iterator cend() const;

Valore restituito

Iteratore bidirezionale const che punta alla posizione successiva all'ultimo elemento di un oggetto hash_multiset. Se l'oggetto hash_multiset è vuoto, hash_multiset::cend == hash_multiset::begin.

Osservazioni:

cend viene usato per verificare se un iteratore ha raggiunto la fine del relativo oggetto hash_multiset. Non è consigliabile dereferenziare il valore restituito da cend.

Esempio

// hash_multiset_cend.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hs1;
   hash_multiset <int> :: const_iterator hs1_cIter;

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

   hs1_cIter = hs1.cend( );
   hs1_cIter--;
   cout << "The last element of hs1 is " << *hs1_cIter << endl;
}

The last element of hs1 is 3

hash_multiset::clear

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Cancella tutti gli elementi di un oggetto hash_multiset.

void clear();

Osservazioni:

Esempio

// hash_multiset_clear.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;

   hms1.insert( 1 );
   hms1.insert( 2 );

   cout << "The size of the hash_multiset is initially " << hms1.size( )
        << "." << endl;

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

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

hash_multiset::const_iterator

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_iterator const_iterator;

Osservazioni:

Un tipo const_iterator non può essere usato per modificare il valore di un elemento.

Esempio

Vedere l'esempio relativo a begin per indicazioni su come usare const_iterator.

hash_multiset::const_pointer

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_pointer const_pointer;

Osservazioni:

Un tipo const_pointer non può essere usato per modificare il valore di un elemento.

Nella maggior parte dei casi, un const_iterator deve essere usato per accedere agli elementi in un const oggetto hash_multiset.

hash_multiset::const_reference

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_reference const_reference;

Osservazioni:

Esempio

// hash_multiset_const_reference.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;

   hms1.insert( 10 );
   hms1.insert( 20 );

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

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

   // The following line would cause an error because the
   // const_reference cannot be used to modify the hash_multiset
   // Ref1 = Ref1 + 5;
}

The first element in the hash_multiset is 10.

hash_multiset::const_reverse_iterator

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Tipo che fornisce un iteratore bidirezionale in grado di leggere qualsiasi const elemento nella hash_multiset.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reverse_iterator const_reverse_iterator;

Osservazioni:

Un tipo const_reverse_iterator non può modificare il valore di un elemento e viene usato per eseguire l'iterazione sull'oggetto hash_multiset in ordine inverso.

Esempio

Vedere l'esempio relativo a rend per indicazioni su come dichiarare e usare const_reverse_iterator.

hash_multiset::count

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

size_type count(const Key& key) const;

Parametri

key
La chiave degli elementi per cui trovare un corrispondenza nell'hash_multiset.

Valore restituito

Il numero di elementi nell'hash_multiset con la chiave specificata dal parametro.

Osservazioni:

La funzione membro restituisce il numero di elementi nell'intervallo seguente:

[ lower_bound(key), upper_bound(key) ).

Esempio

L'esempio seguente illustra l'uso della funzione membro hash_multiset::count.

// hash_multiset_count.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_multiset<int> hms1;
    hash_multiset<int>::size_type i;

    hms1.insert(1);
    hms1.insert(1);

    // Keys do not need to be unique in hash_multiset,
    // so duplicates may exist.
    i = hms1.count(1);
    cout << "The number of elements in hms1 with a sort key of 1 is: "
         << i << "." << endl;

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

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

hash_multiset::crbegin

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

const_reverse_iterator crbegin() const;

Valore restituito

Iteratore bidirezionale const inverso che punta al primo elemento di un oggetto hash_multiset invertito o a quello che è stato l'ultimo elemento dell'oggetto hash_multiset non invertito.

Osservazioni:

crbegin viene usato con un oggetto hash_multiset invertito proprio come hash_multiset::begin viene usato con un oggetto hash_multiset.

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

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

Esempio

// hash_multiset_crbegin.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hs1;
   hash_multiset <int>::const_reverse_iterator hs1_crIter;

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

   hs1_crIter = hs1.crbegin( );
   cout << "The first element in the reversed hash_multiset is "
        << *hs1_crIter << "." << endl;
}

The first element in the reversed hash_multiset is 30.

hash_multiset::crend

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

const_reverse_iterator crend() const;

Valore restituito

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

Osservazioni:

crend viene usato con un oggetto hash_multiset invertito proprio come hash_multiset::end viene usato con un oggetto hash_multiset.

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

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

Esempio

// hash_multiset_crend.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hs1;
   hash_multiset <int>::const_reverse_iterator hs1_crIter;

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

   hs1_crIter = hs1.crend( );
   hs1_crIter--;
   cout << "The last element in the reversed hash_multiset is "
        << *hs1_crIter << "." << endl;
}

The last element in the reversed hash_multiset is 10.

hash_multiset::d ifference_type

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Tipo Signed Integer che specifica la differenza tra due iteratori che puntano a elementi all'interno dello stesso oggetto hash_multiset.

typedef list<typename _Traits::value_type, typename _Traits::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.

Si noti che, sebbene difference_type sia disponibile per tutti gli iteratori che soddisfano i requisiti di un iteratore di input, inclusa la classe degli iteratori bidirezionali supportati da contenitori reversibili come set, la sottrazione tra gli iteratori è supportata solo da iteratori ad accesso casuale forniti da un contenitore ad accesso casuale, ad esempio vector o deque.

Esempio

// hash_multiset_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_set>
#include <algorithm>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter, hms1_bIter, hms1_eIter;

   hms1.insert( 20 );
   hms1.insert( 10 );

   // hash_multiset elements need not be unique
   hms1.insert( 20 );

   hms1_bIter = hms1.begin( );
   hms1_eIter = hms1.end( );

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

   df_typ5 = count( hms1_bIter, hms1_eIter, 5 );
   df_typ10 = count( hms1_bIter, hms1_eIter, 10 );
   df_typ20 = count( hms1_bIter, hms1_eIter, 20 );

   // The keys & hence the elements of a hash_multiset
   // need not be unique and may occur multiple times
   cout << "The number '5' occurs " << df_typ5
        << " times in hash_multiset hms1.\n";
   cout << "The number '10' occurs " << df_typ10
        << " times in hash_multiset hms1.\n";
   cout << "The number '20' occurs " << df_typ20
        << " times in hash_multiset hms1.\n";

   // Count the number of elements in a hash_multiset
   hash_multiset <int>::difference_type  df_count = 0;
   hms1_Iter = hms1.begin( );
   while ( hms1_Iter != hms1_eIter)
   {
      df_count++;
      hms1_Iter++;
   }

   cout << "The number of elements in the hash_multiset hms1 is "
        << df_count << "." << endl;
}

The number '5' occurs 0 times in hash_multiset hms1.
The number '10' occurs 1 times in hash_multiset hms1.
The number '20' occurs 2 times in hash_multiset hms1.
The number of elements in the hash_multiset hms1 is 3.

hash_multiset::emplace

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Inserisce un elemento costruito sul posto in un oggetto hash_multiset.

template <class ValTy>
iterator insert(ValTy&& val);

Parametri

val
Valore di un elemento da inserire nell'oggetto hash_multiset, a meno che l'oggetto hash_multiset non contenga già tale elemento o, più in generale, un elemento la cui la chiave sia ordinata in modo equivalente.

Valore restituito

La funzione membro emplace restituisce un iteratore che punta alla posizione in cui è stato inserito il nuovo elemento.

Osservazioni:

Esempio

// hash_multiset_emplace.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset<string> hms3;
   string str1("a");

   hms3.emplace(move(str1));
   cout << "After the emplace insertion, hms3 contains "
      << *hms3.begin() << "." << endl;
}

After the emplace insertion, hms3 contains a.

hash_multiset::emplace_hint

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Inserisce un elemento costruito sul posto in un oggetto hash_multiset, con un suggerimento sulla posizione.

template <class ValTy>
iterator insert(
    const_iterator where,
    ValTy&& val);

Parametri

where
Posizione in cui iniziare a cercare il punto di inserimento corretto. L'inserimento può verificarsi in un tempo costante ammortizzato, anziché in un tempo logaritmico, se il punto di inserimento segue immediatamente dove.

Valore restituito

La funzione membro hash_multiset::emplace restituisce un iteratore che punta alla posizione in cui il nuovo elemento è stato inserito nell'oggetto hash_multiset.

Osservazioni:

L'inserimento può verificarsi in tempo costante ammortizzato, anziché in tempo logaritmico, se il punto di inserimento segue immediatamente dove.

Esempio

// hash_multiset_emplace_hint.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset<string> hms1;
   string str1("a");

   hms1.insert(hms1.begin(), move(str1));
   cout << "After the emplace insertion, hms1 contains "
      << *hms1.begin() << "." << endl;
}

After the emplace insertion, hms1 contains a.

hash_multiset::empty

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Verifica se un oggetto hash_multiset è vuoto.

bool empty() const;

Valore restituito

true se il hash_multiset è vuoto; false se il hash_multiset non èempty.

Osservazioni:

Esempio

// hash_multiset_empty.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1, hms2;
   hms1.insert ( 1 );

   if ( hms1.empty( ) )
      cout << "The hash_multiset hms1 is empty." << endl;
   else
      cout << "The hash_multiset hms1 is not empty." << endl;

   if ( hms2.empty( ) )
      cout << "The hash_multiset hms2 is empty." << endl;
   else
      cout << "The hash_multiset hms2 is not empty." << endl;
}

The hash_multiset hms1 is not empty.
The hash_multiset hms2 is empty.

hash_multiset::end

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un oggetto hash_multiset.

const_iterator end() const;

iterator end();

Valore restituito

Iteratore bidirezionale che punta alla posizione successiva all'ultimo elemento di un oggetto hash_multiset. Se l'oggetto hash_multiset è vuoto, hash_multiset::end == hash_multiset::begin.

Osservazioni:

end viene usato per verificare se un iteratore ha raggiunto la fine del relativo hash_multiset. Non è consigliabile dereferenziare il valore restituito da end.

Esempio

// hash_multiset_end.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: iterator hms1_Iter;
   hash_multiset <int> :: const_iterator hms1_cIter;

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

   hms1_Iter = hms1.end( );
   hms1_Iter--;
   cout << "The last element of hms1 is " << *hms1_Iter << endl;

   hms1.erase( hms1_Iter );

   // The following 3 lines would err because the iterator is const
   // hms1_cIter = hms1.end( );
   // hms1_cIter--;
   // hms1.erase( hms1_cIter );

   hms1_cIter = hms1.end( );
   hms1_cIter--;
   cout << "The last element of hms1 is now " << *hms1_cIter << endl;
}

The last element of hms1 is 3
The last element of hms1 is now 2

hash_multiset::equal_range

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Restituisce una coppia di iteratori rispettivamente al primo elemento di un oggetto hash_multiset con una chiave maggiore di una chiave specificata e al primo elemento dell'oggetto hash_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 per cui trovare una corrispondenza con la chiave di ordinamento di un elemento presente nell'oggetto hash_multiset in cui si esegue la ricerca.

Valore restituito

Coppia di iteratori in cui il primo è l'elemento lower_bound e il secondo è l'elemento upper_bound della chiave.

Per accedere al primo iteratore di una coppia pr restituita dalla funzione membro, usare pr. prima e 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. second e per dereferenziare l'iteratore superiore associato, usare *( pr. secondo).

Esempio

// hash_multiset_equal_range.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_multiset<int> IntHSet;
   IntHSet hms1;
   hash_multiset <int> :: const_iterator hms1_RcIter;

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

   pair <IntHSet::const_iterator, IntHSet::const_iterator> p1, p2;
   p1 = hms1.equal_range( 20 );

   cout << "The upper bound of the element with "
        << "a key of 20\nin the hash_multiset hms1 is: "
        << *(p1.second) << "." << endl;

   cout << "The lower bound of the element with "
        << "a key of 20\nin the hash_multiset hms1 is: "
        << *(p1.first) << "." << endl;

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

   p2 = hms1.equal_range( 40 );

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

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

hash_multiset::erase

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

iterator erase(iterator where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Parametri

where
Posizione dell'elemento da rimuovere dall'hash_multiset.

first
Posizione del primo elemento rimosso dall'hash_multiset.

last
Posizione oltre l'ultimo elemento rimosso dall'hash_multiset.

key
La chiave degli elementi da rimuovere dall'hash_multiset.

Valore restituito

Per le prime due funzioni, iteratore bidirezionale che definisce il primo elemento rimanente successivo a tutti gli elementi eliminati o un puntatore al termine dell'hash_multiset se tali elementi non sono presenti. Per la terza funzione membro, il numero di elementi rimossi dall'hash_multiset.

Osservazioni:

Le funzioni membro non generano mai un'eccezione.

Esempio

Nell'esempio seguente viene illustrato l'uso della funzione membro hash_multiset::erase.

// hash_multiset_erase.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multiset<int> hms1, hms2, hms3;
    hash_multiset<int> :: iterator pIter, Iter1, Iter2;
    int i;
    hash_multiset<int>::size_type n;

    for (i = 1; i < 5; i++)
    {
        hms1.insert(i);
        hms2.insert(i * i);
        hms3.insert(i - 1);
    }

    // The 1st member function removes an element at a given position
    Iter1 = ++hms1.begin();
    hms1.erase(Iter1);

    cout << "After the 2nd element is deleted,\n"
         << "the hash_multiset hms1 is:" ;
    for (pIter = hms1.begin(); pIter != hms1.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 2nd member function removes elements
    // in the range [ first,  last)
    Iter1 = ++hms2.begin();
    Iter2 = --hms2.end();
    hms2.erase(Iter1, Iter2);

    cout << "After the middle two elements are deleted,\n"
         << "the hash_multiset hms2 is:" ;
    for (pIter = hms2.begin(); pIter != hms2.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 3rd member function removes elements with a given  key
    n = hms3.erase(2);

    cout << "After the element with a key of 2 is deleted,\n"
         << "the hash_multiset hms3 is:" ;
    for (pIter = hms3.begin(); pIter != hms3.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 3rd member function returns the number of elements removed
    cout << "The number of elements removed from hms3 is: "
         << n << "." << endl;

    // The dereferenced iterator can also be used to specify a key
    Iter1 = ++hms3.begin();
    hms3.erase(Iter1);

    cout << "After another element with a key "
         << "equal to that of the 2nd element\n"
         << "is deleted, the hash_multiset hms3 is:" ;
    for (pIter = hms3.begin(); pIter != hms3.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;
}

After the 2nd element is deleted,
the hash_multiset hms1 is: 1 3 4.
After the middle two elements are deleted,
the hash_multiset hms2 is: 16 4.
After the element with a key of 2 is deleted,
the hash_multiset hms3 is: 0 1 3.
The number of elements removed from hms3 is: 1.
After another element with a key equal to that of the 2nd element
is deleted, the hash_multiset hms3 is: 0 3.

hash_multiset::find

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Restituisce un iteratore che punta alla posizione di un elemento in un oggetto hash_multiset che dispone di una chiave equivalente a una chiave specificata.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametri

key
Chiave dell'argomento per cui trovare una corrispondenza in base alla chiave di ordinamento di un elemento presente nell'oggetto hash_multiset in cui si esegue la ricerca.

Valore restituito

Tipo iterator o const_iterator che punta alla posizione di un elemento equivalente a una chiave specificata o che punta alla posizione successiva all'ultimo elemento dell'oggetto hash_multiset se non viene trovata alcuna corrispondenza per la chiave.

Osservazioni:

La funzione membro restituisce un iteratore che punta a un elemento nella hash_multiset la cui chiave di ordinamento è equivalent alla chiave dell'argomento 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 hash_multiset non può essere modificato. Se il valore restituito di find viene assegnato a un iteratoroggetto , è possibile modificare l'oggetto hash_multiset.

Esempio

// hash_multiset_find.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: const_iterator hms1_AcIter, hms1_RcIter;

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

   hms1_RcIter = hms1.find( 20 );
   cout << "The element of hash_multiset hms1 with a key of 20 is: "
        << *hms1_RcIter << "." << endl;

   hms1_RcIter = hms1.find( 40 );

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

   // The element at a specific location in the hash_multiset can be found
   // by using a dereferenced iterator addressing the location
   hms1_AcIter = hms1.end( );
   hms1_AcIter--;
   hms1_RcIter = hms1.find( *hms1_AcIter );
   cout << "The element of hms1 with a key matching "
        << "that of the last element is: "
        << *hms1_RcIter << "." << endl;
}

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

hash_multiset::get_allocator

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Restituisce una copia dell'oggetto allocatore usato per costruire l'oggetto hash_multiset.

Allocator get_allocator() const;

Valore restituito

Allocatore usato dall'oggetto hash_multiset per gestire la memoria, che corrisponde al parametro di modello Allocator della classe.

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

Osservazioni:

Gli allocatori per la classe hash_multiset specificano il modo in cui la classe gestisce la memoria. 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

// hash_multiset_get_allocator.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   // The following lines declare objects
   // that use the default allocator.
   hash_multiset <int, hash_compare <int, less<int> > > hms1;
   hash_multiset <int, hash_compare <int, greater<int> > > hms2;
   hash_multiset <double, hash_compare <double,
      less<double> >, allocator<double> > hms3;

   hash_multiset <int, hash_compare <int,
      greater<int> > >::allocator_type hms2_Alloc;
   hash_multiset <double>::allocator_type hms3_Alloc;
   hms2_Alloc = hms2.get_allocator( );

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

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

   // The following lines create a hash_multiset hms4
   // with the allocator of hash_multiset hms1.
   hash_multiset <int>::allocator_type hms4_Alloc;
   hash_multiset <int> hms4;
   hms4_Alloc = hms2.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated by the other
   if( hms2_Alloc == hms4_Alloc )
   {
      cout << "The allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "The allocators are not interchangeable."
           << endl;
   }
}

hash_multiset::hash_multiset

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

hash_multiset();

explicit hash_multiset(
    const Traits& Comp);

hash_multiset(
    const Traits& Comp,
    const Allocator& Al);

hash_multiset(
    const hash_multiset<Key, Traits, Allocator>& Right);

hash_multiset(
    hash_multiset&& Right
};
hash_multiset (initializer_list<Type> IList);

hash_multiset(
    initializer_list<Tu[e> IList, const Compare& Comp):
hash_multiset(
    initializer_list<Type> IList, const Compare& Comp, const Allocator& Al);

template <class InputIterator>
hash_multiset(
    InputIterator first,
    InputIterator last);

template <class InputIterator>
hash_multiset(
    InputIterator first,
    InputIterator last,
    const Traits& Comp);

template <class InputIterator>
hash_multiset(
    InputIterator first,
    InputIterator last,
    const Traits& Comp,
    const Allocator& Al);

Parametri

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

Comp
Funzione di confronto di tipo const Traits usata per ordinare gli elementi nell'oggetto hash_multiset. Per impostazione predefinita è hash_compare.

A destra
Oggetto hash_multiset di cui l'oggetto hash_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
initializer_list che contiene gli elementi da copiare.

Osservazioni:

Tutti i costruttori archiviano un tipo di oggetto allocatore che gestisce la memoria per l'oggetto hash_multiset e che può essere restituito in un secondo momento chiamando hash_multiset::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 i relativi oggetti hash_multiset.

Tutti i costruttori archiviano un oggetto funzione di tipo Traits che viene usato per stabilire un ordine tra le chiavi dell'oggetto hash_multiset e che può essere restituito in un secondo momento chiamando hash_multiset::key_comp. Per altre informazioni su Traits, vedere l'argomento Classe hash_multiset.

I primi tre costruttori specificano un oggetto iniziale hash_multisetvuoto, 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) da usare. La parola chiave explicit elimina alcuni tipi di conversione automatica del tipo.

Il quarto costruttore sposta .hash_multiset Right

Il quinto, il sesto e il settimo costruttore usano un oggetto initializer_list.

Gli ultimi tre costruttori copiano l'intervallo [ first, last) di un oggetto hash_multiset con un grado di esplicitazione crescente nello specificare il tipo di funzione di confronto della classe Compare e il tipo di allocatore.

L'ordine effettivo degli elementi in un contenitore di set hash dipende dalla funzione hash, dalla funzione di ordinamento e dalla dimensione corrente della tabella hash e, in generale, non può essere previsto come avveniva per il contenitore di set, in cui era determinato solo dalla funzione di ordinamento.

hash_multiset::insert

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Inserisce un elemento o un intervallo di elementi in un oggetto hash_multiset.

iterator insert(
    const Type& value);

iterator insert(
    iterator where,
    const Type& Al);

void insert(
    initializer_list<Type> IList);

iterator insert(
    const Type& value);

iterator insert(
    Iterator where,
    const Type& value);

template <class InputIterator>
void insert(
    InputIterator first,
    InputIterator last);

template <class ValTy>
iterator insert(
    ValTy&& value);

template <class ValTy>
iterator insert(
    const_iterator where,
    ValTy&& value);

Parametri

value
Valore di un elemento da inserire nell'oggetto hash_multiset, a meno che quest'ultimo non contenga già tale elemento o, più in generale, un elemento la cui la chiave sia ordinata in modo equivalente.

first
Posizione del primo elemento da copiare da un oggetto hash_multiset.

last
Posizione immediatamente dopo l'ultimo elemento da copiare da un oggetto hash_multiset.

IList
Oggetto initializer_list che contiene gli elementi da copiare.

Valore restituito

Le prime due funzioni membro di inserimento restituiscono un iteratore che punta alla posizione in cui è stato inserito il nuovo elemento.

Le tre funzioni membro successive usano un oggetto initializer_list.

La terza funzione membro inserisce la sequenza di valori di elemento in un oggetto hash_multiset che corrisponde a ogni elemento interessato da un iteratore nell'intervallo [ first, last) di un oggetto hash_multiset specificato.

Osservazioni:

L'inserimento può verificarsi in un tempo costante ammortizzato per la versione dell'hint di inserimento, anziché in tempo logaritmico, se il punto di inserimento segue immediatamente dove.

hash_multiset::iterator

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Tipo che fornisce un iteratore bidirezionale in grado di leggere o modificare qualsiasi elemento di un oggetto hash_multiset.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::iterator iterator;

Osservazioni:

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

Esempio

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

hash_multiset::key_comp

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Recupera una copia dell'oggetto di confronto usato per ordinare le chiavi di un oggetto hash_multiset.

key_compare key_comp() const;

Valore restituito

Restituisce il parametro del modello hash_multiset Traits, che contiene oggetti funzione utilizzati per eseguire l'hashing e per ordinare gli elementi del contenitore.

Per altre informazioni su Traits , vedere l'argomento classe hash_multiset .

Osservazioni:

L'oggetto archiviato definisce una funzione membro:

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

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

Si noti che key_compare e value_compare sono sinonimi per il parametro di modello Traits. Entrambi i tipi vengono forniti per le classi hash_set e hash_multiset, dove sono identici, per la compatibilità con le classi hash_map e hash_multimap, dove sono distinti.

Esempio

// hash_multiset_key_comp.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_multiset <int, hash_compare < int, less<int> > >hms1;
   hash_multiset<int, hash_compare < int, less<int> > >::key_compare kc1
          = hms1.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 hms1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of hms1."
        << endl;
   }

   hash_multiset <int, hash_compare < int, greater<int> > > hms2;
   hash_multiset<int, hash_compare < int, greater<int> > >::key_compare
         kc2 = hms2.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 hms2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of hms2."
           << endl;
   }
}

hash_multiset::key_compare

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Tipo che fornisce due oggetti funzione, un predicato binario della classe compare in grado di confrontare due valori di elemento di un oggetto hash_multiset per determinarne l'ordine relativo e un predicato unario che genera un hash per gli elementi.

typedef Traits key_compare;

Osservazioni:

key_compare è un sinonimo del parametro del modello Traits.

Per altre informazioni su Traits , vedere l'argomento classe hash_multiset .

Si noti che key_compare e value_compare sono sinonimi per il parametro di modello Traits. Entrambi i tipi vengono forniti per le classi hash_set e hash_multiset, dove sono identici, per la compatibilità con le classi hash_map e hash_multimap, dove sono distinti.

Esempio

Vedere l'esempio relativo a key_comp per indicazioni su come dichiarare e usare key_compare.

hash_multiset::key_type

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

typedef Key key_type;

Osservazioni:

key_type è un sinonimo del parametro del modello Key.

Si noti che key_type e value_type sono sinonimi per il parametro di modello Key. Entrambi i tipi vengono forniti per le classi set e multiset, dove sono identici, per la compatibilità con le classi map e multimap, dove sono distinti.

Per altre informazioni su Key, vedere la sezione Osservazioni dell'argomento classe hash_multiset .

Esempio

Vedere l'esempio relativo a value_type per indicazioni su come dichiarare e usare key_type.

hash_multiset::lower_bound

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Restituisce un iteratore al primo elemento di un oggetto hash_multiset con una chiave uguale o maggiore di quella specificata.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parametri

key
Chiave dell'argomento per cui trovare una corrispondenza con la chiave di ordinamento di un elemento presente nell'oggetto hash_multiset in cui si esegue la ricerca.

Valore restituito

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

Osservazioni:

Esempio

// hash_multiset_lower_bound.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main() {
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: const_iterator hms1_AcIter, hms1_RcIter;

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

   hms1_RcIter = hms1.lower_bound( 20 );
   cout << "The element of hash_multiset hms1 with a key of 20 is: "
        << *hms1_RcIter << "." << endl;

   hms1_RcIter = hms1.lower_bound( 40 );

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

   // An element at a specific location in the hash_multiset can be found
   // by using a dereferenced iterator that addresses the location
   hms1_AcIter = hms1.end( );
   hms1_AcIter--;
   hms1_RcIter = hms1.lower_bound( *hms1_AcIter );
   cout << "The element of hms1 with a key matching "
        << "that of the last element is: "
        << *hms1_RcIter << "." << endl;
}

hash_multiset::max_size

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Restituisce la lunghezza massima dell'oggetto hash_multiset.

size_type max_size() const;

Valore restituito

Lunghezza massima possibile dell'oggetto hash_multiset.

Osservazioni:

Esempio

// hash_multiset_max_size.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::size_type i;

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

hash_multiset::operator=

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Sostituisce gli elementi dell'oggetto hash_multiset con una copia di un altro oggetto hash_multiset.

hash_multiset& operator=(const hash_multiset& right);

hash_multiset& operator=(hash_multiset&& right);

Parametri

right
Classe hash_multiset copiata nell'oggetto hash_multiset.

Osservazioni:

Dopo aver cancellato tutti gli elementi esistenti in un hash_multisetoggetto , operator= copia o sposta il contenuto di destra in hash_multiset.

Esempio

// hash_multiset_operator_as.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset<int> v1, v2, v3;
   hash_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;
}

hash_multiset::p ointer

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Tipo che fornisce un puntatore a un elemento di un oggetto hash_multiset.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::pointer pointer;

Osservazioni:

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

Nella maggior parte dei casi, è consigliabile usare un tipo iterator per accedere agli elementi di un oggetto multiset.

hash_multiset::rbegin

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Restituisce un iteratore che punta al primo elemento di un oggetto hash_multiset invertito.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valore restituito

Iteratore bidirezionale inverso che punta al primo elemento di un oggetto hash_multiset invertito o a quello che è stato l'ultimo elemento dell'oggetto hash_multiset non invertito.

Osservazioni:

rbegin viene usato con un oggetto hash_multiset invertito proprio come begin viene usato con un oggetto hash_multiset.

Se il valore restituito di rbegin viene assegnato a un const_reverse_iterator, l'oggetto hash_multiset non può essere modificato. Se il valore restituito di rbegin viene assegnato a un reverse_iterator, l'oggetto hash_multiset può essere modificato.

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

Esempio

// hash_multiset_rbegin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter;
   hash_multiset <int>::reverse_iterator hms1_rIter;

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

   hms1_rIter = hms1.rbegin( );
   cout << "The first element in the reversed hash_multiset is "
        << *hms1_rIter << "." << endl;

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

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

   // A hash_multiset element can be erased by dereferencing to its key
   hms1_rIter = hms1.rbegin( );
   hms1.erase ( *hms1_rIter );

   hms1_rIter = hms1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed hash_multiset is "<< *hms1_rIter << "."
        << endl;
}

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

hash_multiset::reference

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Tipo che fornisce un riferimento a un elemento archiviato in un oggetto hash_multiset.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::reference reference;

Osservazioni:

Esempio

// hash_multiset_reference.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;

   hms1.insert( 10 );
   hms1.insert( 20 );

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

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

   // The value of the 1st element of the hash_multiset can be
   // changed by operating on its (non const) reference
   Ref1 = Ref1 + 5;

   cout << "The first element in the hash_multiset is now "
        << *hms1.begin() << "." << endl;
}

The first element in the hash_multiset is 10.
The first element in the hash_multiset is now 15.

hash_multiset::rend

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

const_reverse_iterator rend() const;

reverse_iterator rend();

Valore restituito

Osservazioni:

rend viene usato con un oggetto hash_multiset invertito proprio come end viene usato con un oggetto hash_multiset.

Se il valore restituito di rend viene assegnato a un const_reverse_iterator, l'oggetto hash_multiset non può essere modificato. Se il valore restituito di rend viene assegnato a un reverse_iterator, l'oggetto hash_multiset può essere modificato. Non è consigliabile dereferenziare il valore restituito da rend.

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

Esempio

// hash_multiset_rend.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter;
   hash_multiset <int>::reverse_iterator hms1_rIter;
   hash_multiset <int>::const_reverse_iterator hms1_crIter;

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

   hms1_rIter = hms1.rend( );
   hms1_rIter--;
   cout << "The last element in the reversed hash_multiset is "
        << *hms1_rIter << "." << endl;

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

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

   hms1_rIter = hms1.rend( );
   hms1_rIter--;
   hms1.erase ( *hms1_rIter );

   hms1_rIter = hms1.rend( );
   hms1_rIter--;
   cout << "After the erasure, the last element in the "
        << "reversed hash_multiset is " << *hms1_rIter << "."
        << endl;
}

The last element in the reversed hash_multiset is 10.
The hash_multiset is: 10 20 30 .
The reversed hash_multiset is: 30 20 10 .
After the erasure, the last element in the reversed hash_multiset is 20.

hash_multiset::reverse_iterator

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

typedef list<typename Traits::value_type, typename Traits::allocator_type>::reverse_iterator reverse_iterator;

Osservazioni:

Un tipo reverse_iterator viene usato per eseguire l'iterazione sull'oggetto hash_multiset in ordine inverso.

Esempio

Vedere l'esempio relativo a rbegin per indicazioni su come dichiarare e usare reverse_iterator.

hash_multiset::size

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Restituisce il numero di elementi nell'oggetto hash_multiset.

size_type size() const;

Valore restituito

Lunghezza corrente dell'oggetto hash_multiset.

Osservazioni:

Esempio

// hash_multiset_size.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: size_type i;

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

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

The hash_multiset length is 1.
The hash_multiset length is now 2.

hash_multiset::size_type

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::size_type size_type;

Osservazioni:

Esempio

Vedere l'esempio relativo a size per indicazioni su come dichiarare e usare size_type.

hash_multiset::swap

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Scambia gli elementi di due oggetti hash_multiset.

void swap(hash_multiset& right);

Parametri

right
Argomento di tipo hash_multiset che fornisce gli elementi da scambiare con l'oggetto hash_multiset di destinazione.

Osservazioni:

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

Esempio

// hash_multiset_swap.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1, hms2, hms3;
   hash_multiset <int>::iterator hms1_Iter;

   hms1.insert( 10 );
   hms1.insert( 20 );
   hms1.insert( 30 );
   hms2.insert( 100 );
   hms2.insert( 200 );
   hms3.insert( 300 );

   cout << "The original hash_multiset hms1 is:";
   for ( hms1_Iter = hms1.begin( ); hms1_Iter != hms1.end( );
         hms1_Iter++ )
         cout << " " << *hms1_Iter;
   cout   << "." << endl;

   // This is the member function version of swap
   hms1.swap( hms2 );

   cout << "After swapping with hms2, list hms1 is:";
   for ( hms1_Iter = hms1.begin( ); hms1_Iter != hms1.end( );
         hms1_Iter++ )
         cout << " " << *hms1_Iter;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hms1, hms3 );

   cout << "After swapping with hms3, list hms1 is:";
   for ( hms1_Iter = hms1.begin( ); hms1_Iter != hms1.end( );
         hms1_Iter++ )
         cout << " " << *hms1_Iter;
   cout   << "." << endl;
}

The original hash_multiset hms1 is: 10 20 30.
After swapping with hms2, list hms1 is: 200 100.
After swapping with hms3, list hms1 is: 300.

hash_multiset::upper_bound

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Restituisce un iteratore al primo elemento di un oggetto hash_multiset con una chiave maggiore di quella specificata.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parametri

key
Chiave dell'argomento per cui trovare una corrispondenza con la chiave di ordinamento di un elemento presente nell'oggetto hash_multiset in cui si esegue la ricerca.

Valore restituito

Tipo iterator o const_iterator che punta alla posizione del primo elemento di un oggetto hash_multiset con una chiave maggiore della chiave dell'argomento o che punta alla posizione successiva all'ultimo elemento dell'oggetto hash_multiset se non viene trovata alcuna corrispondenza per la chiave.

Osservazioni:

Esempio

// hash_multiset_upper_bound.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: const_iterator hms1_AcIter, hms1_RcIter;

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

   hms1_RcIter = hms1.upper_bound( 20 );
   cout << "The first element of hash_multiset hms1" << endl
        << "with a key greater than 20 is: "
        << *hms1_RcIter << "." << endl;

   hms1_RcIter = hms1.upper_bound( 30 );

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

   // An element at a specific location in the hash_multiset can be
   // found by using a dereferenced iterator addressing the location
   hms1_AcIter = hms1.begin( );
   hms1_RcIter = hms1.upper_bound( *hms1_AcIter );
   cout << "The first element of hms1 with a key greater than "
        << endl << "that of the initial element of hms1 is: "
        << *hms1_RcIter << "." << endl;
}

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

hash_multiset::value_comp

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

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

value_compare value_comp() const;

Valore restituito

Restituisce il parametro del modello hash_multiset Traits, che contiene oggetti funzione utilizzati per eseguire l'hashing e per ordinare gli elementi del contenitore.

Per altre informazioni su Traits , vedere l'argomento classe hash_multiset .

Osservazioni:

L'oggetto archiviato definisce una funzione membro:

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

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

Esempio

// hash_multiset_value_comp.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_multiset <int, hash_compare < int, less<int> > > hms1;
   hash_multiset <int, hash_compare < int, less<int> > >::value_compare
      vc1 = hms1.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 hms1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of hms1."
           << endl;
   }

   hash_multiset <int, hash_compare < int, greater<int> > > hms2;
   hash_multiset<int, hash_compare < int, greater<int> > >::
           value_compare vc2 = hms2.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 hms2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of hms2."
           << endl;
   }
}

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

hash_multiset::value_compare

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

typedef key_compare value_compare;

Osservazioni:

value_compare è un sinonimo del parametro del modello Traits.

Per altre informazioni su Traits , vedere l'argomento classe hash_multiset .

Si noti che sia key_compare value_compare che sono sinonimi per il parametro del modello Traits. Entrambi i tipi vengono forniti per le classi set e multiset, dove sono identici, per la compatibilità con le classi map e multimap, dove sono distinti.

Esempio

Vedere l'esempio relativo a value_comp per indicazioni su come dichiarare e usare value_compare.

hash_multiset::value_type

Nota

Questa API è obsoleta. L'alternativa è la classe unordered_multiset.

Tipo che descrive un oggetto archiviato come elemento di un oggetto hash_multiset in qualità di valore.

typedef Key value_type;

Esempio

// hash_multiset_value_type.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter;

   // Declare value_type
   hash_multiset <int> :: value_type hmsvt_Int;

   hmsvt_Int = 10;   // Initialize value_type

   // Declare key_type
   hash_multiset <int> :: key_type hmskt_Int;
   hmskt_Int = 20;             // Initialize key_type

   hms1.insert( hmsvt_Int );         // Insert value into s1
   hms1.insert( hmskt_Int );         // Insert key into s1

   // A hash_multiset accepts key_types or value_types as elements
   cout << "The hash_multiset has elements:";
   for ( hms1_Iter = hms1.begin() ; hms1_Iter != hms1.end( );
         hms1_Iter++)
      cout << " " << *hms1_Iter;
      cout << "." << endl;
}

The hash_multiset has elements: 10 20.

Vedi anche

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

Condividi tramite

Classe hash_multiset

Sintassi

Parametri

Osservazioni:

Costruttori

Typedef

Funzioni membro

Operatori

Requisiti

hash_multiset::allocator_type

Esempio

hash_multiset::begin

Valore restituito

Osservazioni:

Esempio

hash_multiset::cbegin

Valore restituito

Osservazioni:

Esempio

hash_multiset::cend

Valore restituito

Osservazioni:

Esempio

hash_multiset::clear

Osservazioni:

Esempio

hash_multiset::const_iterator

Osservazioni:

Esempio

hash_multiset::const_pointer

Osservazioni:

hash_multiset::const_reference

Osservazioni:

Esempio

hash_multiset::const_reverse_iterator

Osservazioni:

Esempio

hash_multiset::count

Parametri

Valore restituito

Osservazioni:

Esempio

hash_multiset::crbegin

Valore restituito

Osservazioni:

Esempio

hash_multiset::crend

Valore restituito

Osservazioni:

Esempio

hash_multiset::d ifference_type

Osservazioni:

Esempio

hash_multiset::emplace

Parametri

Valore restituito

Osservazioni:

Esempio

hash_multiset::emplace_hint

Parametri

Valore restituito

Osservazioni:

Esempio

hash_multiset::empty

Valore restituito

Osservazioni:

Esempio

hash_multiset::end

Valore restituito

Osservazioni:

Esempio

hash_multiset::equal_range

Parametri

Valore restituito

Esempio

hash_multiset::erase

Parametri

Valore restituito

Osservazioni: