Classe unordered_multiset

Il modello di classe descrive un oggetto che controlla una sequenza di lunghezza variabile di elementi di tipo const Key. La sequenza viene ordinata in modo debole da una funzione hash, che esegue il partizionamento della sequenza in un set ordinato di sottosequenze denominate bucket. In ogni bucket una funzione di confronto determina se una coppia di elementi ha un ordinamento equivalente. Ogni elemento viene utilizzato sia come chiave di ordinamento che come valore. La sequenza viene rappresentata in modo da consentire la ricerca, l'inserimento e la rimozione di un elemento arbitrario mediante una serie di operazioni che possono essere indipendenti dal numero di elementi della sequenza (tempo costante), almeno quando tutti i bucket sono più o meno lunghi uguali. Nella peggiore delle ipotesi, quando tutti gli elementi si trovano in un unico bucket, il numero di operazioni è proporzionale al numero di elementi della sequenza (tempo lineare). Inoltre, l'inserimento di un elemento non invalida gli iteratori e la rimozione di un elemento invalida solo gli iteratori che fanno riferimento all'elemento rimosso.

Sintassi

template <class Key,
    class Hash = std::hash<Key>,
    class Pred = std::equal_to<Key>,
    class Alloc = std::allocator<Key>>
class unordered_multiset;

Parametri

Chiave
Tipo di chiave.

Hash
Tipo di oggetto della funzione hash.

Pred
Tipo di oggetto della funzione di confronto di uguaglianza.

Alloc
Classe Allocator.

Membri

Definizione del tipo Descrizione
allocator_type Tipo di un allocatore per gestire l'archiviazione.
const_iterator Tipo di un iteratore costante per la sequenza controllata.
const_local_iterator Tipo di un iteratore di bucket costante per la sequenza controllata.
const_pointer Tipo di un puntatore costante a un elemento.
const_reference Tipo di un riferimento costante a un elemento.
difference_type Tipo di una distanza Signed tra due elementi.
Hasher Tipo della funzione hash.
iterator Tipo di un iteratore per la sequenza controllata.
key_equal Tipo della funzione di confronto.
key_type Tipo di una chiave di ordinamento.
local_iterator Tipo di un iteratore di bucket per la sequenza controllata.
pointer Tipo di un puntatore a un elemento.
reference Tipo di un riferimento a un elemento.
size_type Tipo di una distanza Unsigned tra due elementi.
value_type Tipo di un elemento.
Funzione membro Descrizione
begin Indica l'inizio della sequenza controllata.
secchio Ottiene il numero di bucket relativo a un valore della chiave.
bucket_count Ottiene il numero di bucket.
bucket_size Ottiene le dimensioni di un bucket.
cbegin Indica l'inizio della sequenza controllata.
cend Designa la fine della sequenza controllata.
deselezionare Rimuove tutti gli elementi.
contieneC++20 Controlla se è presente un elemento con la chiave specificata.
count Trova il numero di elementi corrispondenti a una chiave specificata.
emplace Aggiunge un elemento costruito sul posto.
emplace_hint Aggiunge un elemento costruito sul posto, con il suggerimento.
empty Verifica se sono presenti o meno degli elementi.
end Designa la fine della sequenza controllata.
equal_range Trova un intervallo che corrisponde a una chiave specificata.
erase Rimuove gli elementi in corrispondenza delle posizioni specificate.
find Trova un elemento che corrisponde a una chiave specificata.
get_allocator Ottiene l'oggetto allocatore archiviato.
hash_function Ottiene l'oggetto della funzione hash archiviato.
insert Aggiunge elementi.
key_eq Ottiene l'oggetto archiviato della funzione di confronto.
load_factor Conta il numero medio di elementi per bucket.
max_bucket_count Ottiene il numero massimo di bucket.
max_load_factor Ottiene o imposta il numero massimo di elementi per bucket.
max_size Ottiene la dimensione massima della sequenza controllata.
centone Ricompila la tabella hash.
size Conta il numero di elementi.
swap Scambia il contenuto di due contenitori.
unordered_multiset Costruisce un oggetto contenitore.
Operatore Descrizione
unordered_multiset::operator= Copia una tabella hash.

Osservazioni:

L'oggetto ordina la sequenza da esso controllata chiamando due oggetti archiviati, un oggetto della funzione di confronto di tipo unordered_multiset::key_equal e un oggetto della funzione hash di tipo unordered_multiset::hasher. È possibile accedere al primo oggetto archiviato chiamando la funzione membro unordered_multiset::key_eq() ed è possibile accedere al secondo oggetto archiviato chiamando la funzione membro unordered_multiset::hash_function(). In particolare, per tutti i valori X e Y di tipo Key, la chiamata a key_eq()(X, Y) restituisce true solo se i valori dei due argomenti hanno un ordinamento equivalente; la chiamata a hash_function()(keyval) produce una distribuzione di valori di tipo size_t. A differenza del modello di classe unordered_set Class, un oggetto di tipo unordered_multiset non garantisce che key_eq()(X, Y) sia sempre false per due elementi della sequenza controllata. Le chiavi non devono essere necessariamente univoche.

L'oggetto consente inoltre di archiviare un fattore di carico massimo che specifica il numero medio massimo di elementi per bucket desiderato. Se l'inserimento di un elemento comporta il superamento del fattore di carico massimo da parte di unordered_multiset::load_factor(), il contenitore aumenta il numero dei bucket e ricompila la tabella hash in base alle necessità.

L'ordine effettivo degli elementi nella sequenza controllata dipende dalla funzione hash, dalla funzione di confronto, dall'ordine di inserimento, dal fattore di carico massimo e dal numero corrente di bucket. Non è in genere possibile prevedere l'ordine degli elementi nella sequenza selezionata. Si può tuttavia avere sempre la certezza dell'adiacenza dei subset di elementi con un ordinamento equivalente nella sequenza controllata.

L'oggetto alloca e libera la memoria per la sequenza da esso controllata tramite un oggetto allocatore archiviato di tipo unordered_multiset::allocator_type. Un oggetto allocatore di questo tipo deve avere la stessa interfaccia esterna di un oggetto di tipo allocator. Si noti che l'oggetto allocatore archiviato non viene copiato dopo l'assegnazione dell'oggetto contenitore.

Requisiti

Intestazione:<unordered_set>

Spazio dei nomi: std

unordered_multiset::allocator_type

Tipo di un allocatore per gestire l'archiviazione.

typedef Alloc allocator_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Alloc.

Esempio

// std__unordered_set__unordered_multiset_allocator_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
    Myset c1;

    Myset::allocator_type al = c1.get_allocator();
    std::cout << "al == std::allocator() is "
        << std::boolalpha << (al == Myalloc()) << std::endl;

    return (0);
}
al == std::allocator() is true

unordered_multiset::begin

Designa l'inizio della sequenza controllata o di un bucket.

iterator begin();

const_iterator begin() const;

local_iterator begin(size_type nbucket);

const_local_iterator begin(size_type nbucket) const;

Parametri

nbucket
Numero di bucket.

Osservazioni:

Le prime due funzioni membro restituiscono un iteratore in avanti che punta al primo elemento della sequenza (o appena oltre la fine di una sequenza vuota). Le ultime due funzioni membro restituiscono un iteratore in avanti che punta al primo elemento del bucket nbucket (o appena oltre la fine di un bucket vuoto).

Esempio

// std__unordered_set__unordered_multiset_begin.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect first two items "[c] [b]"
    Myset::iterator it2 = c1.begin();
    std::cout << "[" << *it2 << "] ";
    ++it2;
    std::cout << "[" << *it2 << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}
[c] [b] [a]
[c] [b]
[a]

unordered_multiset::bucket

Ottiene il numero di bucket relativo a un valore della chiave.

size_type bucket(const Key& keyval) const;

Parametri

keyval
Valore della chiave da mappare.

Osservazioni:

La funzione membro restituisce il numero di bucket che corrisponde attualmente al valore della chiave keyval.

Esempio

// std__unordered_set__unordered_multiset_bucket.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display buckets for keys
    Myset::size_type bs = c1.bucket('a');
    std::cout << "bucket('a') == " << bs << std::endl;
    std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
        << std::endl;

    return (0);
}
[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1

unordered_multiset::bucket_count

Ottiene il numero di bucket.

size_type bucket_count() const;

Osservazioni:

La funzione membro restituisce il numero corrente di bucket.

Esempio

// std__unordered_set__unordered_multiset_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;

    return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multiset::bucket_size

Ottiene le dimensioni di un bucket.

size_type bucket_size(size_type nbucket) const;

Parametri

nbucket
Numero di bucket.

Osservazioni:

Le funzioni membro restituiscono le dimensioni del numero di bucket nbucket.

Esempio

// std__unordered_set__unordered_multiset_bucket_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display buckets for keys
    Myset::size_type bs = c1.bucket('a');
    std::cout << "bucket('a') == " << bs << std::endl;
    std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
        << std::endl;

    return (0);
}
[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1

unordered_multiset::cbegin

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

const_iterator cbegin() const;

Valore restituito

Iteratore di accesso in avanti 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 dell'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

unordered_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 in avanti 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

Non è consigliabile dereferenziare il valore restituito da cend.

unordered_multiset::clear

Rimuove tutti gli elementi.

void clear();

Osservazioni:

La funzione membro chiama unordered_multiset::erase( unordered_multiset::begin(), unordered_multiset::end.())

Esempio

// std__unordered_set__unordered_multiset_clear.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}
[c] [b] [a]
size == 0
empty() == true

[e] [d]
size == 2
empty() == false

unordered_multiset::const_iterator

Tipo di un iteratore costante per la sequenza controllata.

typedef T1 const_iterator;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come iteratore costante in avanti per la sequenza controllata. Qui è descritto come sinonimo del tipo definito dall'implementazione T1.

Esempio

// std__unordered_set__unordered_multiset_const_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}
[c] [b] [a]

unordered_multiset::const_local_iterator

Tipo di un iteratore di bucket costante per la sequenza controllata.

typedef T5 const_local_iterator;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come iteratore in avanti costante per un bucket. Qui è descritto come sinonimo del tipo definito dall'implementazione T5.

Esempio

// std__unordered_set__unordered_multiset_const_local_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}
[c] [b] [a]
[a]

unordered_multiset::const_pointer

Tipo di un puntatore costante a un elemento.

typedef Alloc::const_pointer const_pointer;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come puntatore costante a un elemento della sequenza controllata.

Esempio

// std__unordered_set__unordered_multiset_const_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::const_pointer p = &*it;
        std::cout << "[" << *p << "] ";
        }
    std::cout << std::endl;

    return (0);
}
[c] [b] [a]

unordered_multiset::const_reference

Tipo di un riferimento costante a un elemento.

typedef Alloc::const_reference const_reference;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come riferimento costante a un elemento della sequenza controllata.

Esempio

// std__unordered_set__unordered_multiset_const_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::const_reference ref = *it;
        std::cout << "[" << ref << "] ";
        }
    std::cout << std::endl;

    return (0);
}
[c] [b] [a]

unordered_multiset::contains

Controlla se è presente un elemento con la chiave specificata in unordered_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.

Esempio

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

int main()
{
    std::unordered_multiset<int> theUnorderedMultiset = { 1, 2, 3 };

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << theUnorderedMultiset.contains(1) << '\n';
    std::cout << theUnorderedMultiset.contains(4) << '\n';

    return 0;
}
true
false

unordered_multiset::count

Trova il numero di elementi corrispondenti a una chiave specificata.

size_type count(const Key& keyval) const;

Parametri

keyval
Valore della chiave da cercare.

Osservazioni:

La funzione membro restituisce il numero di elementi nell'intervallo delimitato da unordered_multiset::equal_range(keyval).

Esempio

// std__unordered_set__unordered_multiset_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "count('A') == " << c1.count('A') << std::endl;
    std::cout << "count('b') == " << c1.count('b') << std::endl;
    std::cout << "count('C') == " << c1.count('C') << std::endl;

    return (0);
}
[c] [b] [a]
count('A') == 0
count('b') == 1
count('C') == 0

unordered_multiset::difference_type

Tipo di una distanza Signed tra due elementi.

typedef T3 difference_type;

Osservazioni:

Il tipo di valore integer con segno descrive un oggetto che può rappresentare la differenza tra gli indirizzi di due elementi qualsiasi della sequenza controllata. Qui è descritto come sinonimo del tipo definito dall'implementazione T3.

Esempio

// std__unordered_set__unordered_multiset_difference_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // compute positive difference
    Myset::difference_type diff = 0;
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        ++diff;
    std::cout << "end()-begin() == " << diff << std::endl;

    // compute negative difference
    diff = 0;
    for (Myset::const_iterator it = c1.end();
        it != c1.begin(); --it)
        --diff;
    std::cout << "begin()-end() == " << diff << std::endl;

    return (0);
}
[c] [b] [a]
end()-begin() == 3
begin()-end() == -3

unordered_multiset::emplace

Inserisce un elemento costruito sul posto, senza che vengano eseguite operazioni di copia o spostamento.

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

Parametri

args
Argomenti inoltrati per costruire un elemento da inserire nell'oggetto unordered_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 che non si trova nella funzione hash del contenitore, quest'ultimo non viene modificato. Se l'eccezione viene generata nella funzione hash, il risultato non sarà definito.

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

unordered_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 unordered_multiset.

where
Suggerimento sulla posizione per avviare la ricerca del punto di inserimento corretto.

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 che non si trova nella funzione hash del contenitore, quest'ultimo non viene modificato. Se l'eccezione viene generata nella funzione hash, il risultato non sarà definito.

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

unordered_multiset::empty

Verifica se sono presenti o meno degli elementi.

bool empty() const;

Osservazioni:

La funzione membro restituisce true per una sequenza controllata vuota.

Esempio

// std__unordered_set__unordered_multiset_empty.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}
[c] [b] [a]
size == 0
empty() == true

[e] [d]
size == 2
empty() == false

unordered_multiset::end

Designa la fine della sequenza controllata.

iterator end();
const_iterator end() const;
local_iterator end(size_type nbucket);
const_local_iterator end(size_type nbucket) const;

Parametri

nbucket
Numero di bucket.

Osservazioni:

Le prime due funzioni membro restituiscono un iteratore in avanti che punta poco oltre la fine della sequenza. Le ultime due funzioni membro restituiscono un iteratore in avanti che punta appena oltre la fine del bucket nbucket.

Esempio

// std__unordered_set__unordered_multiset_end.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect last two items "[a] [b]"
    Myset::iterator it2 = c1.end();
    --it2;
    std::cout << "[" << *it2 << "] ";
    --it2;
    std::cout << "[" << *it2 << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.end(c1.bucket('a'));
    --lit;
    std::cout << "[" << *lit << "] ";

    return (0);
}
[c] [b] [a]
[a] [b]
[a]

unordered_multiset::equal_range

Trova un intervallo che corrisponde a una chiave specificata.

std::pair<iterator, iterator>
    equal_range(const Key& keyval);

std::pair<const_iterator, const_iterator>
    equal_range(const Key& keyval) const;

Parametri

keyval
Valore della chiave da cercare.

Osservazioni:

La funzione membro restituisce una coppia di iteratori X in modo che [X.first, X.second) delimiti solo gli elementi della sequenza controllata con ordinamento equivalente con keyval. Se tali elementi non esistono, entrambi gli iteratori sono end().

Esempio

// std__unordered_set__unordered_multiset_equal_range.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display results of failed search
    std::pair<Myset::iterator, Myset::iterator> pair1 =
        c1.equal_range('x');
    std::cout << "equal_range('x'):";
    for (; pair1.first != pair1.second; ++pair1.first)
        std::cout << "[" << *pair1.first << "] ";
    std::cout << std::endl;

    // display results of successful search
    pair1 = c1.equal_range('b');
    std::cout << "equal_range('b'):";
    for (; pair1.first != pair1.second; ++pair1.first)
        std::cout << "[" << *pair1.first << "] ";
    std::cout << std::endl;

    return (0);
}
[c] [b] [a]
equal_range('x'):
equal_range('b'): [b]

unordered_multiset::erase

Rimuove un elemento o un intervallo di elementi in un multiset non ordinato 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.

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

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

Valore restituito

Per le prime due funzioni, iteratore bidirezionale che definisce il primo elemento rimanente successivo a tutti gli elementi eliminati o un elemento che rappresenta la fine del multiset non ordinato se non tali elementi non sono presenti.

Per la terza funzione membro, restituisce il numero di elementi rimossi dal multiset non ordinato.

Osservazioni:

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

unordered_multiset::find

Trova un elemento che corrisponde a una chiave specificata.

const_iterator find(const Key& keyval) const;

Parametri

keyval
Valore della chiave da cercare.

Osservazioni:

La funzione membro restituisce unordered_multiset::equal_range(keyval).first.

Esempio

// std__unordered_set__unordered_multiset_find.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // try to find and fail
    std::cout << "find('A') == "
        << std::boolalpha << (c1.find('A') != c1.end()) << std::endl;

    // try to find and succeed
    Myset::iterator it = c1.find('b');
    std::cout << "find('b') == "
        << std::boolalpha << (it != c1.end())
        << ": [" << *it << "] " << std::endl;

    return (0);
}
[c] [b] [a]
find('A') == false
find('b') == true: [b]

unordered_multiset::get_allocator

Ottiene l'oggetto allocatore archiviato.

Alloc get_allocator() const;

Osservazioni:

La funzione membro restituisce l'oggetto allocatore archiviato.

Esempio

// std__unordered_set__unordered_multiset_get_allocator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
    Myset c1;

    Myset::allocator_type al = c1.get_allocator();
    std::cout << "al == std::allocator() is "
        << std::boolalpha << (al == Myalloc()) << std::endl;

    return (0);
}
al == std::allocator() is true

unordered_multiset::hash_function

Ottiene l'oggetto della funzione hash archiviato.

Hash hash_function() const;

Osservazioni:

La funzione membro restituisce l'oggetto archiviato della funzione hash.

Esempio

// std__unordered_set__unordered_multiset_hash_function.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::hasher hfn = c1.hash_function();
    std::cout << "hfn('a') == " << hfn('a') << std::endl;
    std::cout << "hfn('b') == " << hfn('b') << std::endl;

    return (0);
}
hfn('a') == 1630279
hfn('b') == 1647086

unordered_multiset::hasher

Tipo della funzione hash.

typedef Hash hasher;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Hash.

Esempio

// std__unordered_set__unordered_multiset_hasher.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::hasher hfn = c1.hash_function();
    std::cout << "hfn('a') == " << hfn('a') << std::endl;
    std::cout << "hfn('b') == " << hfn('b') << std::endl;

    return (0);
}
hfn('a') == 1630279
hfn('b') == 1647086

unordered_multiset::insert

Inserisce un elemento o un intervallo di elementi in un oggetto unordered_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 in unordered_multiset.

Where
Posizione in cui iniziare a cercare il punto di inserimento corretto.

ValTy
Parametro di modello che specifica il tipo di argomento che l'unordered_multiset può usare per costruire un elemento di value_type e inoltra perfettamente Val come argomento.

First
Posizione del primo elemento da copiare.

Ultimo
Posizione immediatamente dopo l'ultimo elemento da copiare.

InputIterator
Argomento della funzione modello che soddisfa i requisiti di un iteratore di input che punta agli elementi di un tipo utilizzabili per costruire oggetti value_type.

IList
Oggetto initializer_list da cui copiare gli elementi.

Valore restituito

Le funzioni membro di inserimento a elemento singolo, (1) e (2), restituiscono un iteratore alla posizione in cui il nuovo elemento è stato inserito in unordered_multiset.

Le funzioni membro a elemento singolo con suggerimento, (3) e (4), restituiscono un iteratore che fa riferimento alla posizione in cui il nuovo elemento è stato inserito in unordered_multiset.

Osservazioni:

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

Se viene generata un'eccezione durante l'inserimento di un solo elemento, ma l'eccezione non si manifesta nella funzione hash del contenitore, lo stato del contenitore non verrà modificato. Se l'eccezione viene generata nella funzione hash, il risultato non sarà definito. 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 appartenente al contenitore e, per set, unordered_multiset<V>::value_type è di tipo const V.

La funzione membro dell'intervallo (5) inserisce la sequenza di valori degli elementi in un unordered_multiset 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 m.insert(v.begin(), v.end());, ad esempio, cerca di inserire tutti gli elementi di v in m.

La funzione membro di elenco di inizializzatori (6) usa un oggetto initializer_list per copiare gli elementi nell'oggetto unordered_multiset.

Per l'inserimento di un elemento costruito sul posto, ovvero senza operazioni di copia o spostamento, vedere unordered_multiset::emplace e unordered_multiset::emplace_hint.

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

unordered_multiset::iterator

Tipo che fornisce un iteratore in avanti costante in grado di leggere gli elementi in un oggetto unordered_multset.

typedef implementation-defined iterator;

Esempio

Vedere l'esempio relativo a begin per indicazioni su come dichiarare e usare un iteratore.

unordered_multiset::key_eq

Ottiene l'oggetto archiviato della funzione di confronto.

Pred key_eq() const;

Osservazioni:

La funzione membro restituisce l'oggetto archiviato della funzione di confronto.

Esempio

// std__unordered_set__unordered_multiset_key_eq.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::key_equal cmpfn = c1.key_eq();
    std::cout << "cmpfn('a', 'a') == "
        << std::boolalpha << cmpfn('a', 'a') << std::endl;
    std::cout << "cmpfn('a', 'b') == "
        << std::boolalpha << cmpfn('a', 'b') << std::endl;

    return (0);
}
cmpfn('a', 'a') == true
cmpfn('a', 'b') == false

unordered_multiset::key_equal

Tipo della funzione di confronto.

typedef Pred key_equal;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Pred.

Esempio

// std__unordered_set__unordered_multiset_key_equal.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::key_equal cmpfn = c1.key_eq();
    std::cout << "cmpfn('a', 'a') == "
        << std::boolalpha << cmpfn('a', 'a') << std::endl;
    std::cout << "cmpfn('a', 'b') == "
        << std::boolalpha << cmpfn('a', 'b') << std::endl;

    return (0);
}
cmpfn('a', 'a') == true
cmpfn('a', 'b') == false

unordered_multiset::key_type

Tipo di una chiave di ordinamento.

typedef Key key_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Key.

Esempio

// std__unordered_set__unordered_multiset_key_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // add a value and reinspect
    Myset::key_type key = 'd';
    Myset::value_type val = key;
    c1.insert(val);

    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}
[c] [b] [a]
[d] [c] [b] [a]

unordered_multiset::load_factor

Conta il numero medio di elementi per bucket.

float load_factor() const;

Osservazioni:

La funzione membro restituisce (float)unordered_multiset::size() / (float)unordered_multiset::bucket_count(), il numero medio di elementi per bucket.

Esempio

// std__unordered_set__unordered_multiset_load_factor.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}

unordered_multiset::local_iterator

Tipo di iteratore di bucket.

typedef T4 local_iterator;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come iteratore in avanti per un bucket. Qui è descritto come sinonimo del tipo definito dall'implementazione T4.

Esempio

// std__unordered_set__unordered_multiset_local_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}
[c] [b] [a]
[a]

unordered_multiset::max_bucket_count

Ottiene il numero massimo di bucket.

size_type max_bucket_count() const;

Osservazioni:

La funzione membro restituisce il numero massimo di bucket attualmente consentiti.

Esempio

// std__unordered_set__unordered_multiset_max_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multiset::max_load_factor

Ottiene o imposta il numero massimo di elementi per bucket.

float max_load_factor() const;

void max_load_factor(float factor);

Parametri

fattore
Nuovo fattore di carico massimo.

Osservazioni:

La prima funzione membro restituisce il fattore di carico massimo archiviato. La seconda funzione membro sostituisce il fattore di carico massimo archiviato con il fattore .

Esempio

// std__unordered_set__unordered_multiset_max_load_factor.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multiset::max_size

Ottiene la dimensione massima della sequenza controllata.

size_type max_size() const;

Osservazioni:

La funzione membro restituisce la lunghezza della sequenza più lunga che l'oggetto può controllare.

Esempio

// std__unordered_set__unordered_multiset_max_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    std::cout << "max_size() == " << c1.max_size() << std::endl;

    return (0);
}
max_size() == 4294967295

unordered_multiset::operator=

Copia una tabella hash.

unordered_multiset& operator=(const unordered_multiset& right);

unordered_multiset& operator=(unordered_multiset&& right);

Parametri

right
Oggetto unordered_multiset copiato nell'oggetto unordered_multiset.

Osservazioni:

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

Esempio

// unordered_multiset_operator_as.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

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

unordered_multiset::pointer

Tipo di un puntatore a un elemento.

typedef Alloc::pointer pointer;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come puntatore a un elemento della sequenza controllata.

Esempio

// std__unordered_set__unordered_multiset_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::key_type key = *it;
        Myset::pointer p = &key;
        std::cout << "[" << *p << "] ";
        }
    std::cout << std::endl;

    return (0);
}
[c] [b] [a]

unordered_multiset::reference

Tipo di un riferimento a un elemento.

typedef Alloc::reference reference;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come riferimento a un elemento della sequenza controllata.

Esempio

// std__unordered_set__unordered_multiset_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::key_type key = *it;
        Myset::reference ref = key;
        std::cout << "[" << ref << "] ";
        }
    std::cout << std::endl;

    return (0);
}
[c] [b] [a]

unordered_multiset::rehash

Ricompila la tabella hash.

void rehash(size_type nbuckets);

Parametri

nbuckets
Numero di bucket richiesto.

Osservazioni:

La funzione membro modifica il numero di bucket in modo che siano almeno nbucket e ricompila la tabella hash in base alle esigenze.

Esempio

// std__unordered_set__unordered_multiset_rehash.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;

    return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 0.1

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

unordered_multiset::size

Conta il numero di elementi.

size_type size() const;

Osservazioni:

La funzione membro restituisce la lunghezza della sequenza controllata.

Esempio

// std__unordered_set__unordered_multiset_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}
[c] [b] [a]
size == 0
empty() == true

[e] [d]
size == 2
empty() == false

unordered_multiset::size_type

Tipo di una distanza Unsigned tra due elementi.

typedef T2 size_type;

Osservazioni:

Il tipo Unsigned Integer descrive un oggetto che può rappresentare la lunghezza di una sequenza controllata. Qui è descritto come sinonimo del tipo definito dall'implementazione T2.

Esempio

// std__unordered_set__unordered_multiset_size_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;
    Myset::size_type sz = c1.size();

    std::cout << "size == " << sz << std::endl;

    return (0);
}
size == 0

unordered_multiset::swap

Scambia il contenuto di due contenitori.

void swap(unordered_multiset& right);

Parametri

right
Contenitore con cui eseguire lo scambio.

Osservazioni:

La funzione membro scambia le sequenze controllate tra *this e destra. Se unordered_multiset::get_allocator() == right.get_allocator(), esegue l'operazione in un tempo costante, genera un'eccezione solo in seguito alla copia dell'oggetto traits archiviato di tipo Tr e non invalida alcun riferimento, puntatore o iteratore che definisce gli elementi nelle due sequenze controllate. In caso contrario, esegue un numero di assegnazioni di elementi e chiamate al costruttore proporzionale al numero di elementi nelle due sequenze controllate.

Esempio

// std__unordered_set__unordered_multiset_swap.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    Myset c2;

    c2.insert('d');
    c2.insert('e');
    c2.insert('f');

    c1.swap(c2);

    // display contents "[f] [e] [d]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    swap(c1, c2);

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}
[c] [b] [a]
[f] [e] [d]
[c] [b] [a]

unordered_multiset::unordered_multiset

Costruisce un oggetto contenitore.

unordered_multiset(
    const unordered_multiset& Right);

explicit unordered_multiset(
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

unordered_multiset(
    unordered_multiset&& Right);

unordered_set(
    initializer_list<Type> IList);

unordered_set(
    initializer_list<Typ> IList,
    size_type Bucket_count);

unordered_set(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash);

unordered_set(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    const Key& Key);

unordered_set(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    const Key& Key,
    const Allocator& Al);

template <class InputIterator>
unordered_multiset(
    InputIterator First,
    InputIterator Last,
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

Parametri

InputIterator
Tipo di iteratore.

Ale
Oggetto allocatore da archiviare.

Comp
Oggetto della funzione di confronto da archiviare.

Hash
Oggetto della funzione hash da archiviare.

Bucket_count
Numero minimo di bucket.

Right
Contenitore da copiare.

IList
Oggetto initializer_list da cui copiare gli elementi.

Osservazioni:

Il primo costruttore specifica una copia della sequenza controllata da Right. Il secondo costruttore specifica una sequenza controllata vuota. In terzo costruttore inserisce la sequenza di valori degli elementi [First, Last). Il quarto costruttore specifica una copia della sequenza spostando Right.

Tutti i costruttori inizializzano inoltre diversi valori archiviati. Per il costruttore di copia, i valori vengono ottenuti da Right. Altrimenti:

Il numero minimo di bucket è l'argomento Bucket_count, se presente; in caso contrario, è un valore predefinito descritto qui come valore N0definito dall'implementazione .

L'oggetto funzione hash è l'argomento Hash, se presente; in caso contrario, è Hash().

L'oggetto funzione di confronto è l'argomento Comp, se presente; in caso contrario, è Comp().

L'oggetto allocatore è l'argomento Al, se presente; in caso contrario, è Alloc().

unordered_multiset::value_type

Tipo di un elemento.

typedef Key value_type;

Osservazioni:

Il tipo descrive un elemento nella sequenza controllata.

Esempio

// std__unordered_set__unordered_multiset_value_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // add a value and reinspect
    Myset::key_type key = 'd';
    Myset::value_type val = key;
    c1.insert(val);

    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}
[c] [b] [a]
[d] [c] [b] [a]

Vedi anche

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