Classe `unordered_set`

Articolo
10/12/2023

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. All'interno di ogni bucket, una funzione di confronto determina se qualsiasi 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). L'inserimento di un elemento non invalida alcun iteratore e la rimozione di un elemento invalida solo gli iteratori che puntano 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_set;

Parametri

Key
Tipo di chiave.

Hash
Tipo di oggetto della funzione hash.

Pred
Tipo di oggetto della funzione di confronto di uguaglianza.

Alloc
Classe Allocator.

Membri

Typedef

Nome	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.

Funzioni

Nome	Descrizione
`begin`	Indica l'inizio della sequenza controllata.
`bucket`	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.
`clear`	Rimuove tutti gli elementi.
`contains`^C++20	Controllare se è presente un elemento con la chiave specificata in `unordered_set`.
`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.
`rehash`	Ricompila la tabella hash.
`size`	Conta il numero di elementi.
`swap`	Scambia il contenuto di due contenitori.
`unordered_set`	Costruisce un oggetto contenitore.

Operatori

Nome	Descrizione
`unordered_set::operator=`	Copia una tabella hash.

Osservazioni:

L'oggetto ordina la sequenza che controlla chiamando due oggetti archiviati, un oggetto funzione di confronto di tipo e un oggetto funzione hash di tipo unordered_set::key_equal unordered_set::hasher. Per accedere al primo oggetto archiviato, chiamare la funzione unordered_set::key_eq()membro e accedere al secondo oggetto archiviato chiamando la funzione unordered_set::hash_function()membro . 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 della Classe modellounordered_multiset di classe, un oggetto di tipo unordered_set garantisce che key_eq()(X, Y) sia sempre false per due elementi della sequenza controllata. Le chiavi sono 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 causa unordered_set::load_factor() il superamento del fattore di carico massimo, il contenitore aumenta il numero di bucket e ricompila la tabella hash in base alle esigenze.

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 è possibile prevedere in generale l'ordine degli elementi nella sequenza controllata. 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 l'archiviazione per la sequenza che controlla tramite un oggetto allocatore archiviato di tipo unordered_set::allocator_type. Un oggetto allocatore di questo tipo deve avere la stessa interfaccia esterna di un oggetto di tipo allocator. L'oggetto allocatore archiviato non viene copiato quando viene assegnato l'oggetto contenitore.

`unordered_set::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_set_allocator_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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

// unordered_set_begin.cpp
// compile using: cl.exe /EHsc /nologo /W4 /MTd
#include <unordered_set>
#include <iostream>

using namespace std;

typedef unordered_set<char> MySet;

int main()
{
    MySet c1;

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

    // display contents using range-based for
    for (auto it : c1) {
    cout << "[" << it << "] ";
    }

    cout << endl;

    // display contents using explicit for
    for (MySet::const_iterator it = c1.begin(); it != c1.end(); ++it) {
        cout << "[" << *it << "] ";
    }

    cout << std::endl;

    // display first two items
    MySet::iterator it2 = c1.begin();
    cout << "[" << *it2 << "] ";
    ++it2;
    cout << "[" << *it2 << "] ";
    cout << endl;

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

    return (0);
}

[a] [b] [c]
[a] [b] [c]
[a] [b]
[a]

`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_set_bucket.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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_set_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`bucket_size`

Ottiene le dimensioni di un bucket.

size_type bucket_size(size_type nbucket) const;

Parametri

nbucket
Numero di bucket.

Osservazioni:

La funzione membro restituisce la dimensione del numero di bucket nbucket.

Esempio

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

typedef std::unordered_set<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

`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 nell'intervallo non possono essere modificati.

È possibile usare questa funzione membro anziché la funzione membro begin() per garantire che il valore restituito sia const_iterator. In genere, viene usato insieme alla parola chiave di deduzione del auto tipo, 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 isContainer<T>::iterator
auto i2 = Container.cbegin();

// i2 isContainer<T>::const_iterator

`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 usato insieme alla parola chiave di deduzione del auto tipo, 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 isContainer<T>::iterator
auto i2 = Container.cend();

// i2 isContainer<T>::const_iterator

Il valore restituito da cend non deve essere dereferenziato.

`clear`

Rimuove tutti gli elementi.

void clear();

Osservazioni:

La funzione membro chiama unordered_set::erase( unordered_set::begin(), unordered_set::end()). Per altre informazioni, vedere unordered_set::erase, unordered_set::begin e unordered_set::end.

Esempio

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

typedef std::unordered_set<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

`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. Viene descritto qui come sinonimo del tipo T1definito dall'implementazione .

Esempio

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

typedef std::unordered_set<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]

`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. Viene descritto qui come sinonimo del tipo T5definito dall'implementazione .

Esempio

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

typedef std::unordered_set<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]

`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_set_const_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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]

`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_set_const_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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]

`contains`

Controlla se è presente un elemento con la chiave specificata in unordered_set.

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_set<int> theUnorderedSet = { 1, 2 };

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

    return 0;
}

true
false

`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_set::equal_range(keyval).

Esempio

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

typedef std::unordered_set<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

`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. Viene descritto qui come sinonimo del tipo T3definito dall'implementazione .

Esempio

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

typedef std::unordered_set<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

`emplace`

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

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

Parametri

args
Argomenti inoltrati per costruire un elemento da inserire in unordered_set , a meno che non contenga già un elemento il cui valore è ordinato in modo equivalente.

Valore restituito

Oggetto pair il cui componente bool restituisce true se è stato effettuato un inserimento e false se in unordered_set è già contenuto un elemento la cui chiave ha un valore equivalente nell'ordinamento e il cui componente iteratore restituisce l'indirizzo in cui è stato inserito un nuovo elemento o in cui si trovava già l'elemento.

Per accedere al componente iteratore di una coppia pr restituita da questa funzione membro, usare pr.first e per deferenziarlo, usare *(pr.first). Per accedere al componente bool di una coppia pr restituita da questa funzione membro, usare pr.second.

Osservazioni:

Questa funzione non invalida alcun iteratore né riferimento.

Durante l'inserimento, se viene generata un'eccezione ma non si verifica nella funzione hash del contenitore, il contenitore non viene modificato. Se l'eccezione viene generata nella funzione hash, il risultato non sarà definito.

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

`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_iteratorwhere,
Args&&... args);

Parametri

args
Argomenti inoltrati per costruire un elemento da inserire nell'oggetto unordered_set a meno che l'elemento unordered_set non contenga già tale elemento o, più in generale, a meno che non contenga già un elemento la cui chiave è ordinata in modo equivalente.

where
Suggerimento sulla posizione in cui iniziare a cercare il punto di inserimento corretto.

Valore restituito

Iteratore all'elemento appena inserito.

Se l'inserimento ha avuto esito negativo perché l'elemento esiste già, restituisce un iteratore all'elemento esistente.

Osservazioni:

Questa funzione non invalida alcun iteratore né riferimento.

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

`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_set_empty.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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 poco oltre la fine del bucket nbucket.

Esempio

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

typedef std::unordered_set<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]

`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 tale che [X.first, X.second) delimiti solo gli elementi della sequenza controllata associati a un ordinamento equivalente a keyval. Se tali elementi non esistono, entrambi gli iteratori sono end().

Esempio

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

typedef std::unordered_set<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]

`erase`

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

iterator erase(const_iterator Where);

iterator erase(const_iterator First, const_iterator Last);

size_type erase(const key_type& Key);

Parametri

Where
Posizione dell'elemento che deve essere rimosso.

First
Posizione del primo elemento che deve essere rimosso.

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

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

Valore restituito

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

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

Osservazioni:

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

`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 restituisceunordered_set::equal_range(keyval).first.

Esempio

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

typedef std::unordered_set<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]

`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_set_get_allocator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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_set_hash_function.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`hasher`

Tipo della funzione hash.

typedef Hash hasher;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Hash.

Esempio

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

typedef std::unordered_set<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

`insert`

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

// (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_set , a meno che non contenga già un elemento la cui chiave è ordinata in modo equivalente.

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

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

First
Posizione del primo elemento da copiare.

Last
Posizione immediatamente dopo l'ultimo elemento da copiare.

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

IList
Oggetto initializer_list da cui copiare gli elementi.

Valore restituito

Le funzioni membro a singolo elemento, (1) e (2), restituiscono un pair il cui bool componente è true se è stato effettuato un inserimento e false se l'elemento unordered_set contiene già un elemento la cui chiave ha un valore equivalente nell'ordinamento. Il componente iteratore della coppia return-value punta all'elemento appena inserito se il bool componente è trueo all'elemento esistente se il bool componente è false.

Le funzioni membro single-element-with-hint, (3) e (4), restituiscono un iteratore che punta alla posizione in cui è stato inserito il nuovo elemento nell'oggetto unordered_set o, se esiste già un elemento con una chiave equivalente, all'elemento esistente.

Osservazioni:

Non ci sono iteratori, puntatori o riferimenti invalidati da questa funzione.

Durante l'inserimento di un solo elemento, se viene generata un'eccezione ma non si verifica nella funzione hash del contenitore, lo stato del contenitore non viene 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.

Per accedere al componente iteratore di un pair pr oggetto restituito dalle funzioni membro a singolo elemento, usare pr.first; per dereferenziare l'iteratore all'interno della coppia restituita, usare*pr.first, fornendo un elemento . Per accedere al componente bool, usare pr.second. Per un esempio, vedere il codice di esempio più avanti in questo articolo.

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

La funzione membro dell'intervallo (5) inserisce la sequenza di valori di elemento in un unordered_set oggetto che corrisponde a ogni elemento indirizzato da un iteratore nell'intervallo [First, Last), pertanto Last non viene inserito. La funzione membro di contenitore end() fa riferimento alla posizione immediatamente dopo l'ultimo elemento nel contenitore. L'istruzione s.insert(v.begin(), v.end());, ad esempio, cerca di inserire tutti gli elementi di v in s. Solo gli elementi che hanno valori univoci nell'intervallo vengono inseriti; i duplicati vengono ignorati. Per osservare quali elementi vengono rifiutati, usare le versioni con un singolo elemento di insert.

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

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

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

`iterator`

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

typedef implementation-defined iterator;

Esempio

Vedere l'esempio per begin un esempio di come dichiarare e usare un iteratore.

`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_set_key_eq.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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_set_key_equal.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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_set_key_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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]

`load_factor`

Conta il numero medio di elementi per bucket.

float load_factor() const;

Osservazioni:

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

Esempio

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

typedef std::unordered_set<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

`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. Viene descritto qui come sinonimo del tipo T4definito dall'implementazione .

Esempio

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

typedef std::unordered_set<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]

`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_set_max_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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

factor
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 factor.

Esempio

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

typedef std::unordered_set<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

`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_set_max_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

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

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

    return (0);
}

max_size() == 4294967295

`operator=`

Copia una tabella hash.

unordered_set& operator=(const unordered_set& right);

unordered_set& operator=(unordered_set&& right);

Parametri

right
Oggetto unordered_set copiato in unordered_set.

Osservazioni:

Dopo la cancellazione di tutti gli elementi esistenti in un oggetto unordered_set, operator= copia o sposta il contenuto di right nell'oggetto unordered_set.

Esempio

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

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

`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_set_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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]

`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_set_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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]

`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 da essere almeno pari a nbuckets e ricompila la tabella hash in base alle esigenze.

Esempio

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

typedef std::unordered_set<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

`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_set_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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. Viene descritto qui come sinonimo del tipo T2definito dall'implementazione .

Esempio

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

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

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

    return (0);
}

size == 0

`swap`

Scambia il contenuto di due contenitori.

void swap(unordered_set& right);

Parametri

right
Contenitore con cui eseguire lo scambio.

Osservazioni:

La funzione membro scambia le sequenze controllate tra *this e right. Se unordered_set::get_allocator() == right.get_allocator(), lo fa in tempo costante, genera un'eccezione solo in seguito alla copia dell'oggetto tratti archiviati di tipo Tre non invalida riferimenti, puntatori o iteratori che designano 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_set_swap.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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_set`

Costruisce un oggetto contenitore.

unordered_set(const unordered_set& Right);

explicit unordered_set(
    size_typebucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

unordered_set(unordered_set&& Right);

unordered_set(initializer_list<Type> IList);

unordered_set(initializer_list<Type> IList, size_typebucket_count);

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

unordered_set(
    initializer_list<Type> IList,
    size_typebucket_count,
    const Hash& Hash,
    const Comp& Comp);

unordered_set(
    initializer_list<Type> IList,
    size_typebucket_count,
    const Hash& Hash,
    const Comp& Comp,
    const Allocator& Al);

template <class InputIterator>
unordered_set(
    InputIteratorfirst,
    InputIteratorlast,
    size_typebucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

Parametri

InputIterator
Tipo di iteratore.

Al
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 contenente gli elementi da copiare.

Osservazioni:

Il primo costruttore specifica una copia della sequenza controllata da Right. Il secondo costruttore specifica una sequenza controllata vuota. Il terzo costruttore specifica una copia della sequenza spostando Right Il quarto tramite l'ottavo costruttore usa un initializer_list oggetto per specificare gli elementi da copiare. Il nono costruttore inserisce la sequenza di valori degli elementi [first, last).

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

`value_type`

Tipo di un elemento.

typedef Key value_type;

Osservazioni:

Il tipo descrive un elemento nella sequenza controllata.

Esempio

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

typedef std::unordered_set<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]

Condividi tramite

Classe unordered_set

Sintassi

Parametri

Membri

Typedef

Funzioni

Operatori

Osservazioni:

unordered_set::allocator_type

Osservazioni:

Esempio

begin

Parametri

Osservazioni:

Esempio

bucket

Parametri

Osservazioni:

Esempio

bucket_count

Osservazioni:

Esempio

bucket_size

Parametri

Osservazioni:

Esempio

cbegin

Valore restituito

Osservazioni:

cend

Valore restituito

Osservazioni:

clear

Osservazioni:

Esempio

const_iterator

Osservazioni:

Esempio

const_local_iterator

Osservazioni:

Esempio

const_pointer

Osservazioni:

Esempio

const_reference

Osservazioni:

Esempio

contains

Parametri

Valore restituito

Osservazioni:

Esempio

count

Parametri

Osservazioni:

Esempio

difference_type

Osservazioni:

Esempio

emplace

Parametri

Valore restituito

Osservazioni:

emplace_hint

Parametri

Valore restituito

Osservazioni:

empty

Osservazioni:

Esempio

end

Parametri

Osservazioni:

Esempio

equal_range

Parametri

Osservazioni:

Esempio

erase

Classe `unordered_set`

`unordered_set::allocator_type`

`begin`

`bucket`

`bucket_count`

`bucket_size`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_local_iterator`

`const_pointer`

`const_reference`

`contains`

`count`

`difference_type`

`emplace`

`emplace_hint`

`empty`

`end`

`equal_range`

`erase`

`find`

`get_allocator`

`hash_function`

`hasher`

`insert`

`iterator`

`key_eq`

`key_equal`

`key_type`

`load_factor`

`local_iterator`

`max_bucket_count`

`max_load_factor`

`max_size`

`operator=`

`pointer`

`reference`

`rehash`

`size`

`size_type`

`swap`