Clase `unordered_set`

Artículo
06/16/2023

La plantilla de clase describe un objeto que controla una secuencia de longitud variable de elementos de tipo const Key. La secuencia está ordenada débilmente por una función hash, que divide la secuencia en un conjunto ordenado subsecuencias denominadas depósitos. Dentro de cada depósito una función de comparación determina si algún par de elementos tiene una ordenación equivalente. Cada elemento actúa como clave de ordenación y como valor. La secuencia se representan de tal forma que permite la búsqueda, inserción y eliminación de un elemento arbitrario con una serie de operaciones que pueden ser independientes del número de elementos de la secuencia (tiempo constante), al menos cuando todos los depósitos tienen una longitud aproximadamente igual. En el peor de los casos, cuando todos los elementos están en un depósito, el número de operaciones es proporcional al número de elementos de la secuencia (tiempo lineal). La inserción de un elemento no invalida ningún iterador y al quitar un elemento solo se invalidan los iteradores que apuntan al elemento quitado.

Sintaxis

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

Parámetros

Key
El tipo de clave.

Hash
El tipo de objeto de la función hash.

Pred
El tipo de objeto de función de comparación de igualdad.

Alloc
Clase de asignador.

Miembros

Typedefs

Nombre	Descripción
`allocator_type`	El tipo de un asignador para administrar el almacenamiento.
`const_iterator`	El tipo de un iterador constante para la secuencia controlada.
`const_local_iterator`	El tipo de un iterador de depósito constante para la secuencia controlada.
`const_pointer`	El tipo de un puntero constante a un elemento.
`const_reference`	El tipo de una referencia constante a un elemento.
`difference_type`	El tipo de una distancia con signo entre dos elementos.
`hasher`	El tipo de la función hash.
`iterator`	El tipo de un iterador para la secuencia controlada.
`key_equal`	El tipo de la función de comparación.
`key_type`	El tipo de una clave de ordenación.
`local_iterator`	El tipo de un iterador de depósito para la secuencia controlada.
`pointer`	El tipo de un puntero a un elemento.
`reference`	El tipo de una referencia a un elemento.
`size_type`	El tipo de una distancia sin signo entre dos elementos.
`value_type`	El tipo de un elemento.

Funciones

Nombre	Descripción
`begin`	Designa el principio de la secuencia controlada.
`bucket`	Obtiene el número de depósito para un valor de clave.
`bucket_count`	Obtiene el número de depósitos.
`bucket_size`	Obtiene el tamaño de un depósito.
`cbegin`	Designa el principio de la secuencia controlada.
`cend`	Designa el final de la secuencia controlada.
`clear`	Quita todos los elementos.
`contains`^C++20	Compruebe si hay un elemento con la clave especificada en `unordered_set`.
`count`	Busca el número de elementos que coinciden con una clave especificada.
`emplace`	Agrega un elemento construido en contexto.
`emplace_hint`	Agrega un elemento construido en contexto, con sugerencia.
`empty`	Comprueba si no hay ningún elemento presente.
`end`	Designa el final de la secuencia controlada.
`equal_range`	Busca el intervalo que coincide con una clave especificada.
`erase`	Quita los elementos de las posiciones especificadas.
`find`	Busca un elemento que coincide con una clave especificada.
`get_allocator`	Obtiene el objeto de asignador almacenado.
`hash_function`	Obtiene el objeto de función hash almacenado.
`insert`	Agrega elementos.
`key_eq`	Obtiene el objeto de función de comparación almacenado.
`load_factor`	Cuenta los elementos promedio por depósito.
`max_bucket_count`	Obtiene el número máximo de depósitos.
`max_load_factor`	Obtiene o establece los elementos máximos por depósito.
`max_size`	Obtiene el tamaño máximo de la secuencia controlada.
`rehash`	Recompila la tabla hash.
`size`	Cuenta el número de elementos.
`swap`	Intercambia el contenido de dos contenedores.
`unordered_set`	Construye un objeto contenedor.

Operadores

Nombre	Descripción
`unordered_set::operator=`	Copia una tabla hash.

Comentarios

El objeto ordena la secuencia que controla llamando a dos objetos almacenados, un objeto de función de comparación de tipo unordered_set::key_equal y un objeto de función hash de tipo unordered_set::hasher. Se tiene acceso al primer objeto almacenado llamando a la función miembro unordered_set::key_eq(); y se tiene acceso al segundo objeto almacenado llamando a la función miembro unordered_set::hash_function(). Concretamente, para todos los valores X e Y de tipo Key, la llamada a key_eq()(X, Y) solo devuelve true si los dos valores de argumento tienen una ordenación equivalente; la llamada a hash_function()(keyval) produce una distribución de valores de tipo size_t. A diferencia de la plantilla de clase unordered_multiset Class, un objeto de tipo unordered_set garantiza que key_eq()(X, Y) es siempre falso para cualquiera de los dos elementos de la secuencia controlada. (Las claves son únicas).

El objeto también almacena un factor de carga máxima, que especifica el número promedio deseado máximo de elementos por depósito. Si la inserción de un elemento hace que unordered_set::load_factor() supere el factor de carga máxima, el contenedor aumenta el número de cubos y recompila la tabla hash según sea necesario.

El orden real de los elementos de la secuencia controlada depende de la función hash, la función de comparación, el orden de inserción, el factor de carga máxima y el número actual de depósitos. En general no se puede predecir el orden de los elementos de la secuencia controlada. Sin embargo, siempre se puede asegurar que cualquier subconjunto de elementos que tengan una ordenación equivalente son adyacentes en la secuencia controlada.

El objeto asigna y libera almacenamiento para la secuencia que controla a través de un objeto asignador almacenado de tipo unordered_set::allocator_type. Ese objeto de asignador debe tener la misma interfaz externa que un objeto de tipo allocator. El objeto asignador almacenado no se copia cuando se asigna el objeto contenedor.

`unordered_set::allocator_type`

El tipo de un asignador para administrar el almacenamiento.

typedef Alloc allocator_type;

Comentarios

El tipo es un sinónimo del parámetro de plantilla Alloc.

Ejemplo

// 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 el principio de la secuencia controlada o un depósito.

iterator begin();

const_iterator begin() const;

local_iterator begin(size_type nbucket);

const_local_iterator begin(size_type nbucket) const;

Parámetros

nbucket
Número de depósito.

Comentarios

Las dos primeras funciones miembro devuelven un iterador hacia delante que apunta al primer elemento de la secuencia (o más allá del final de una secuencia vacía). Las dos últimas funciones miembro devuelven un iterador hacia delante que apunta al primer elemento del depósito nbucket (o más allá del final de un depósito vacío).

Ejemplo

// 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`

Obtiene el número de depósito para un valor de clave.

size_type bucket(const Key& keyval) const;

Parámetros

keyval
Valor de clave que se va a asignar.

Comentarios

La función miembro devuelve el número de depósito que corresponde actualmente al valor de clave keyval.

Ejemplo

// 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`

Obtiene el número de depósitos.

size_type bucket_count() const;

Comentarios

La función miembro devuelve el número actual de depósitos.

Ejemplo

// 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`

Obtiene el tamaño de un depósito.

size_type bucket_size(size_type nbucket) const;

Parámetros

nbucket
Número de depósito.

Comentarios

Las funciones miembro devuelven el tamaño del número de depósito nbucket.

Ejemplo

// 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`

Devuelve un iterador const que direcciona el primer elemento del intervalo.

const_iterator cbegin() const;

Valor devuelto

Iterador const de acceso hacia delante que apunta al primer elemento del intervalo o la ubicación situada más allá del final de un intervalo vacío (para un intervalo vacío, cbegin() == cend()).

Comentarios

Con el valor devuelto de cbegin, los elementos del intervalo no se pueden modificar.

Se puede usar esta función miembro en lugar de la función miembro begin() para garantizar que el valor devuelto es const_iterator. Normalmente, se usa junto con la palabra clave de deducción de tipos auto, como se muestra en el ejemplo siguiente. En el ejemplo se considera que Container es un contenedor modificable (distinto de const) de cualquier naturaleza que admite begin() y cbegin().

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

// i2 isContainer<T>::const_iterator

`cend`

Devuelve un iterador const que direcciona la ubicación situada más allá del último elemento de un intervalo.

const_iterator cend() const;

Valor devuelto

Iterador const de acceso hacia delante que apunta justo después del final del intervalo.

Comentarios

cend se usa para probar si un iterador ha sobrepasado el final de su intervalo.

Se puede usar esta función miembro en lugar de la función miembro end() para garantizar que el valor devuelto es const_iterator. Normalmente, se usa junto con la palabra clave de deducción de tipos auto, como se muestra en el ejemplo siguiente. En el ejemplo se considera que Container es un contenedor modificable (distinto de const) de cualquier naturaleza que admite end() y cend().

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

// i2 isContainer<T>::const_iterator

El valor devuelto por cend no se debe desreferenciar.

`clear`

Quita todos los elementos.

void clear();

Comentarios

La función miembro llama a unordered_set::erase( unordered_set::begin(), unordered_set::end()). Para obtener más información, vea unordered_set::erase, unordered_set::begin y unordered_set::end.

Ejemplo

// 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`

El tipo de un iterador constante para la secuencia controlada.

typedef T1 const_iterator;

Comentarios

El tipo describe un objeto que puede actuar como un iterador de avance constante de la secuencia controlada. Aquí se describe como sinónimo del tipo definido por implementación T1.

Ejemplo

// 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`

El tipo de un iterador de depósito constante para la secuencia controlada.

typedef T5 const_local_iterator;

Comentarios

El tipo describe un objeto que puede actuar como iterador constante hacia delante para un depósito. Aquí se describe como sinónimo del tipo definido por implementación T5.

Ejemplo

// 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`

El tipo de un puntero constante a un elemento.

typedef Alloc::const_pointer const_pointer;

Comentarios

El tipo describe un objeto que puede actuar como puntero constante a un elemento de la secuencia controlada.

Ejemplo

// 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`

El tipo de una referencia constante a un elemento.

typedef Alloc::const_reference const_reference;

Comentarios

El tipo describe un objeto que puede actuar como referencia constante a un elemento de la secuencia controlada.

Ejemplo

// 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`

Comprueba si hay un elemento con la clave especificada en unordered_set.

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

Parámetros

K
Tipo de la clave.

Key
Valor de clave del elemento que se va a buscar.

Valor devuelto

true si el elemento se encuentra en el contenedor; en caso contrario, false.

Comentarios

contains() es nuevo en C++20. Para usarlo, especifique /std:c++20 o una opción de compilador posterior.

template<class K> bool contains(const K& key) const solo participa en la resolución de la sobrecarga si key_compare es transparente.

Ejemplo

// 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`

Busca el número de elementos que coinciden con una clave especificada.

size_type count(const Key& keyval) const;

Parámetros

keyval
Valor de clave que se va a buscar.

Comentarios

La función miembro devuelve el número de elementos incluidos en el rango delimitado por unordered_set::equal_range(keyval).

Ejemplo

// 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`

El tipo de una distancia con signo entre dos elementos.

typedef T3 difference_type;

Comentarios

El tipo de entero con signo describe un objeto que puede representar la diferencia entre las direcciones de dos elementos cualesquiera de la secuencia controlada. Aquí se describe como sinónimo del tipo definido por implementación T3.

Ejemplo

// 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`

Inserta un elemento construido en contexto (no se realiza ninguna operación de copia o de movimiento).

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

Parámetros

args
Argumentos reenviados para construir un elemento unordered_set que se va a insertar en el conjunto, a menos que ya contenga un elemento cuyo valor esté ordenado de forma equivalente.

Valor devuelto

pair cuyo componente bool devuelve true si se realizó una inserción y false si el unordered_set ya contenía un elemento cuya clave tenía un valor equivalente en la ordenación, y cuyo componente de iterador devuelve la dirección donde se ha insertado un nuevo elemento o donde ya estaba el elemento.

Para tener acceso al componente de iterador de un par pr devuelto por esta función miembro, utilice pr.first y, para desreferenciarlo, utilice *(pr.first). Para tener acceso al componente bool de un par pr devuelto por esta función miembro, utilice pr.second.

Comentarios

Esta función no invalida ningún iterador ni ninguna referencia.

Durante la inserción, si se produce una excepción pero no ocurre en la función hash del contenedor, el contenedor no se modifica. Si la excepción se produce en la función hash, el resultado es indefinido.

Para obtener un ejemplo de código, vea set::emplace.

`emplace_hint`

Inserta un elemento construido en contexto (no se realiza ninguna operación de copia o de movimiento), con una sugerencia de colocación.

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

Parámetros

args
Argumentos reenviados para construir un elemento que se va a insertar en unordered_set a menos que unordered_set ya contenga ese elemento o, más en general, a menos que ya contenga un elemento cuya clave esté ordenada de forma equivalente.

where
Sugerencia sobre el lugar para empezar a buscar el punto correcto de inserción.

Valor devuelto

Iterador al elemento recién insertado.

Si se produjo un error en la inserción porque el elemento ya existe, devuelve un iterador al elemento existente.

Comentarios

Esta función no invalida ningún iterador ni ninguna referencia.

Para obtener un ejemplo de código, vea set::emplace_hint.

`empty`

Comprueba si no hay ningún elemento presente.

bool empty() const;

Comentarios

La función miembro devuelve true para una secuencia controlada vacía.

Ejemplo

// 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 el final de la secuencia controlada.

iterator end();

const_iterator end() const;

local_iterator end(size_type nbucket);

const_local_iterator end(size_type nbucket) const;

Parámetros

nbucket
Número de depósito.

Comentarios

Las dos primeras funciones miembro devuelven un iterador hacia delante que apunta inmediatamente después del final de la secuencia. Las dos últimas funciones miembro devuelven un iterador hacia delante que apunta inmediatamente después del final del depósito nbucket.

Ejemplo

// 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`

Busca el intervalo que coincide con una clave especificada.

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

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

Parámetros

keyval
Valor de clave que se va a buscar.

Comentarios

La función miembro devuelve un par de iteradores X tales que[X.first, X.second) delimita únicamente los elementos de la secuencia controlada que tienen una ordenación equivalente con keyval. Si no hay elementos de este tipo, los dos iteradores son end().

Ejemplo

// 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`

Quita un elemento o un intervalo de elementos de una clase unordered_set de las posiciones especificadas o quita los elementos que coinciden con una clave especificada.

iterator erase(const_iterator Where);

iterator erase(const_iterator First, const_iterator Last);

size_type erase(const key_type& Key);

Parámetros

Where
Posición del elemento que se va a quitar.

First
Posición del primer elemento que se va a quitar.

Last
Posición situada más allá del último elemento que se va a quitar.

Key
Valor de clave de los elementos que se van a quitar.

Valor devuelto

En las dos primeras funciones miembro, iterador bidireccional que designa el primer elemento que permanece más allá de los elementos quitados, o un elemento que es el final del objeto unordered_set si no existe ese elemento.

En la tercera función miembro, devuelve el número de elementos que se han quitado de unordered_set.

Comentarios

Para obtener un ejemplo de código, vea set::erase.

`find`

Busca un elemento que coincide con una clave especificada.

const_iterator find(const Key& keyval) const;

Parámetros

keyval
Valor de clave que se va a buscar.

Comentarios

La función miembro devuelve unordered_set::equal_range(keyval).first.

Ejemplo

// 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`

Obtiene el objeto de asignador almacenado.

Alloc get_allocator() const;

Comentarios

La función miembro devuelve el objeto de asignador almacenado.

Ejemplo

// 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`

Obtiene el objeto de función hash almacenado.

Hash hash_function() const;

Comentarios

La función miembro devuelve el objeto de función hash almacenado.

Ejemplo

// 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`

El tipo de la función hash.

typedef Hash hasher;

Comentarios

El tipo es un sinónimo del parámetro de plantilla Hash.

Ejemplo

// 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`

Inserta un elemento o un intervalo de elementos en un 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);

Parámetros

Val
Valor de un elemento que se va a insertar en la unordered_set a menos que ya contenga un elemento cuya clave se ordena de forma equivalente.

Where
Lugar donde se va a iniciar la búsqueda del punto de inserción correcto.

ValTy
Parámetro de plantilla que especifica el tipo de argumento que el objeto unordered_set puede usar para crear un elemento de value_type, y realiza un reenvío directo de Val como argumento.

First
Posición del primer elemento que se va a copiar.

Last
Posición situada más allá del último elemento que se va a copiar.

InputIterator
Argumento de la función de plantilla que cumple los requisitos de un iterador de entrada que apunta a elementos de un tipo que se puede usar para crear objetos value_type.

IList
initializer_list del que se van a copiar los elementos.

Valor devuelto

Las funciones miembro de un solo elemento, (1) y (2), devuelven un objeto pair cuyo componente bool es true si se ha realizado una inserción, y false si unordered_set ya contenía un elemento cuya clave tenía un valor equivalente en la ordenación. El componente iterador del par de valor devuelto apunta al elemento recién insertado si el componente bool es true, o al elemento existente si el componente bool es false.

Las funciones miembro un solo elemento con sugerencia, (3) y (4), devuelven un iterador que apunta a la posición donde se insertó el nuevo elemento en el unordered_set, o bien, si ya existe un elemento con una clave equivalente, al elemento existente.

Comentarios

Esta función no invalida ningún iterador, puntero o referencia.

Durante la inserción de un solo elemento, si se produce una excepción pero no se realiza en la función hash del contenedor, no se modifica el estado del contenedor. Si la excepción se produce en la función hash, el resultado es indefinido. Durante la inserción de varios elementos, si se produce una excepción, el contenedor se deja en un estado sin especificar pero válido.

Para tener acceso al componente de iterador de un que devuelven las funciones miembro de un pair pr solo elemento, use pr.first; para desreferenciar el iterador dentro del par devuelto, use*pr.first , lo que le proporciona un elemento. Para tener acceso al componente bool, utilice pr.second. Para obtener un ejemplo, vea el código de ejemplo que se muestra más adelante en este artículo.

El value_type de un contenedor es una definición de tipo que pertenece al contenedor y, para set, unordered_set<V>::value_type es del tipo const V.

La función miembro de rango (5) inserta la secuencia de valores de elemento en un elemento unordered_set que corresponde a cada elemento direccionado por un iterador en el intervalo [First, Last); por tanto, Last no se inserta. La función miembro de contenedor end() hace referencia a la posición situada justo después del último elemento del contenedor; por ejemplo, la instrucción s.insert(v.begin(), v.end()); intenta insertar todos los elementos de v en s. Solo se insertan los elementos que tienen valores únicos en el intervalo; se omiten los duplicados. Para observar qué elementos se rechazan, utilice las versiones de un solo elemento de insert.

La función miembro de lista de inicializadores (6) usa initializer_list para copiar los elementos en unordered_set.

Para obtener información sobre la inserción de un elemento construido en contexto (es decir, sin realizar ninguna operación de copia o movimiento), vea set::emplace y set::emplace_hint.

Para obtener un ejemplo de código, vea set::insert.

`iterator`

Tipo que proporciona un iterador hacia delante constante que puede leer elementos en un unordered_set.

typedef implementation-defined iterator;

Ejemplo

Vea el ejemplo de begin para obtener un ejemplo de cómo declarar y usar iterator.

`key_eq`

Obtiene el objeto de función de comparación almacenado.

Pred key_eq() const;

Comentarios

La función miembro devuelve el objeto de función de comparación almacenado.

Ejemplo

// 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`

El tipo de la función de comparación.

typedef Pred key_equal;

Comentarios

El tipo es un sinónimo del parámetro de plantilla Pred.

Ejemplo

// 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`

El tipo de una clave de ordenación.

typedef Key key_type;

Comentarios

El tipo es un sinónimo del parámetro de plantilla Key.

Ejemplo

// 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`

Cuenta los elementos promedio por depósito.

float load_factor() const;

Comentarios

La función miembro devuelve (float)unordered_set::size() / (float)unordered_set::bucket_count(), el promedio de elementos por depósito.

Ejemplo

// 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 de un iterador de depósito.

typedef T4 local_iterator;

Comentarios

El tipo describe un objeto que puede actuar como iterador hacia delante para un depósito. Aquí se describe como sinónimo del tipo definido por implementación T4.

Ejemplo

// 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`

Obtiene el número máximo de depósitos.

size_type max_bucket_count() const;

Comentarios

La función miembro devuelve el número máximo de depósitos que se admiten actualmente.

Ejemplo

// 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`

Obtiene o establece los elementos máximos por depósito.

float max_load_factor() const;

void max_load_factor(float factor);

Parámetros

factor
El nuevo factor de carga máxima.

Comentarios

La primera función miembro devuelve el factor de carga máxima almacenado. La segunda función miembro reemplaza el factor de carga máxima almacenado con factor.

Ejemplo

// 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`

Obtiene el tamaño máximo de la secuencia controlada.

size_type max_size() const;

Comentarios

La función miembro devuelve la longitud de la secuencia más larga que puede controlar el objeto.

Ejemplo

// 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 tabla hash.

unordered_set& operator=(const unordered_set& right);

unordered_set& operator=(unordered_set&& right);

Parámetros

right
La clase unordered_set que se copia en unordered_set.

Comentarios

Después de borrar todos los elementos existentes en un unordered_set, operator= copia o mueve el contenido de right a unordered_set.

Ejemplo

// 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`

El tipo de un puntero a un elemento.

typedef Alloc::pointer pointer;

Comentarios

El tipo describe un objeto que puede actuar como puntero a un elemento de la secuencia controlada.

Ejemplo

// 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`

El tipo de una referencia a un elemento.

typedef Alloc::reference reference;

Comentarios

El tipo describe un objeto que puede actuar como referencia a un elemento de la secuencia controlada.

Ejemplo

// 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`

Recompila la tabla hash.

void rehash(size_type nbuckets);

Parámetros

nbuckets
Número solicitado de depósitos.

Comentarios

La función miembro modifica el número de depósitos para que sea al menos nbuckets y vuelve a generar la tabla hash según sea necesario.

Ejemplo

// 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`

Cuenta el número de elementos.

size_type size() const;

Comentarios

La función miembro devuelve la longitud de la secuencia controlada.

Ejemplo

// 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`

El tipo de una distancia sin signo entre dos elementos.

typedef T2 size_type;

Comentarios

El tipo de entero sin signo describe un objeto que puede representar la longitud de cualquier secuencia controlada. Aquí se describe como sinónimo del tipo definido por implementación T2.

Ejemplo

// 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`

Intercambia el contenido de dos contenedores.

void swap(unordered_set& right);

Parámetros

right
El contenedor con el que se intercambia.

Comentarios

La función miembro intercambia las secuencias controladas entre *this y right. Si unordered_set::get_allocator() == right.get_allocator(), lo hace en tiempo constante, produce una excepción solo como resultado de copiar el objeto de rasgos almacenado de tipo Tr y no invalida referencias, punteros o iteradores que designan elementos en las dos secuencias controladas. De lo contrario, realiza varias asignaciones de elementos y llamadas de constructor proporcionales al número de elementos de ambas secuencias controladas.

Ejemplo

// 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`

Construye un objeto contenedor.

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

Parámetros

InputIterator
Tipo de iterador.

Al
Objeto de asignador que se va a almacenar.

Comp
Objeto de función de comparación que se va a almacenar.

Hash
Objeto de función hash que se va a almacenar.

bucket_count
Número mínimo de depósitos.

Right
Contenedor que se va a copiar.

IList
initializer_list que contiene los elementos que se van a copiar.

Comentarios

El primer constructor especifica una copia de la secuencia controlada por Right. El segundo constructor especifica una secuencia controlada vacía. El tercer constructor especifica una copia de la secuencia moviendo Right. Los constructores cuarto a octavo usan una initializer_list para especificar los elementos que se van a copiar. El noveno constructor inserta la secuencia de valores de elemento [first, last).

Todos los constructores también inicializan varios valores almacenados. Para el constructor de copias, los valores se obtienen de Right. De lo contrario:

El número mínimo de depósitos es el argumento bucket_count, si está presente; de lo contrario, es un valor predeterminado descrito aquí como el valor N0 definido por la implementación.

El objeto de función hash es el argumento Hash, si está presente; de lo contrario, es Hash().

El objeto de función de comparación es el argumento Comp, si existe; de lo contrario, es Comp().

El objeto asignador es el argumento Al, si existe; de lo contrario, es Alloc().

`value_type`

El tipo de un elemento.

typedef Key value_type;

Comentarios

El tipo describe un elemento de la secuencia controlada.

Ejemplo

// 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]

Compartir a través de

Clase unordered_set

Sintaxis

Parámetros

Miembros

Typedefs

Funciones

Operadores

Comentarios

unordered_set::allocator_type

Comentarios

Ejemplo

begin

Parámetros

Comentarios

Ejemplo

bucket

Parámetros

Comentarios

Ejemplo

bucket_count

Comentarios

Ejemplo

bucket_size

Parámetros

Comentarios

Ejemplo

cbegin

Valor devuelto

Comentarios

cend

Valor devuelto

Comentarios

clear

Comentarios

Ejemplo

const_iterator

Comentarios

Ejemplo

const_local_iterator

Comentarios

Ejemplo

const_pointer

Comentarios

Ejemplo

const_reference

Comentarios

Ejemplo

contains

Parámetros

Valor devuelto

Comentarios

Ejemplo

count

Parámetros

Comentarios

Ejemplo

difference_type

Comentarios

Ejemplo

emplace

Parámetros

Valor devuelto

Comentarios

emplace_hint

Parámetros

Valor devuelto

Comentarios

empty

Comentarios

Ejemplo

end

Parámetros

Comentarios

Ejemplo

equal_range

Parámetros

Comentarios

Ejemplo

erase

Clase `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`