Se recomienda usar Visual Studio 2017

unordered_set (Clase)

 

Para obtener la documentación más reciente de Visual Studio 2017 RC, consulte Documentación de Visual Studio 2017 RC.

La clase de plantilla describe un objeto que controla una secuencia de longitud variable de elementos de tipoconst 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). Además, 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.

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

Parámetros

ParámetroDescripción
KeyEl tipo de clave.
HashEl tipo de objeto de la función hash.
PredEl tipo de objeto de función de comparación de igualdad.
AllocClase de asignador.
Definición de tipoDescripción
unordered_set::allocator_typeEl tipo de un asignador para administrar el almacenamiento.
unordered_set::const_iteratorEl tipo de un iterador constante para la secuencia controlada.
unordered_set::const_local_iteratorEl tipo de un iterador de depósito constante para la secuencia controlada.
unordered_set::const_pointerEl tipo de un puntero constante a un elemento.
unordered_set::const_referenceEl tipo de una referencia constante a un elemento.
unordered_set::difference_typeEl tipo de una distancia con signo entre dos elementos.
unordered_set::hasherEl tipo de la función hash.
unordered_set::IteratorEl tipo de un iterador para la secuencia controlada.
unordered_set::key_equalEl tipo de la función de comparación.
unordered_set::KEY_TYPEEl tipo de una clave de ordenación.
unordered_set::local_iteratorEl tipo de un iterador de depósito para la secuencia controlada.
unordered_set::pointerEl tipo de un puntero a un elemento.
unordered_set::ReferenceEl tipo de una referencia a un elemento.
unordered_set::size_typeEl tipo de una distancia sin signo entre dos elementos.
unordered_set::value_typeEl tipo de un elemento.
Función miembroDescripción
unordered_set::beginDesigna el principio de la secuencia controlada.
unordered_set::bucketObtiene el número de depósito para un valor de clave.
unordered_set::bucket_countObtiene el número de depósitos.
unordered_set::bucket_sizeObtiene el tamaño de un depósito.
unordered_set::cbeginDesigna el principio de la secuencia controlada.
unordered_set::cendDesigna el final de la secuencia controlada.
unordered_set::ClearQuita todos los elementos.
unordered_set::CountBusca el número de elementos que coinciden con una clave especificada.
unordered_set::emplaceAgrega un elemento construido en contexto.
unordered_set::emplace_hintAgrega un elemento construido en contexto, con sugerencia.
unordered_set::EmptyComprueba si no hay ningún elemento presente.
unordered_set::endDesigna el final de la secuencia controlada.
unordered_set::equal_rangeBusca el intervalo que coincide con una clave especificada.
unordered_set::EraseQuita los elementos de las posiciones especificadas.
unordered_set::FindBusca un elemento que coincide con una clave especificada.
unordered_set::get_allocatorObtiene el objeto de asignador almacenado.
unordered_set::hash_functionObtiene el objeto de función hash almacenado.
unordered_set::InsertAgrega elementos.
unordered_set::key_eqObtiene el objeto de función de comparación almacenado.
unordered_set::load_factorCuenta los elementos promedio por depósito.
unordered_set::max_bucket_countObtiene el número máximo de depósitos.
unordered_set::max_load_factorObtiene o establece los elementos máximos por depósito.
unordered_set::max_sizeObtiene el tamaño máximo de la secuencia controlada.
unordered_set::rehashRecompila la tabla hash.
unordered_set::SizeCuenta el número de elementos.
unordered_set::swapIntercambia el contenido de dos contenedores.
unordered_set::unordered_setConstruye un objeto contenedor.
OperadoresDescripción
unordered_set::operator =Copia una tabla hash.

El objeto ordena la secuencia que controla llamando a dos objetos almacenados, un objeto de función de comparación de tipounordered_set::key_equal y un objeto de función hash de tipounordered_set::hasher. Acceso al primer objeto almacenado llamando a la función miembrounordered_set::key_eq(); y acceso al segundo objeto almacenado llamando a la función miembrounordered_set::hash_function(). Concretamente, para todos los valores deX yY de tipoKey, la llamadakey_eq()(X, Y) solo devuelve true si los dos valores de argumento tienen una ordenación equivalente; la llamada ahash_function()(keyval) produce una distribución de valores de tiposize_t. A diferencia de la clase de plantillaunordered_multiset (clase), un objeto de clase de plantillaunordered_set garantiza quekey_eq()(X, Y) siempre es false para dos elementos cualesquiera 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 hace que insertar un elementounordered_set::load_factor () para superar el factor de carga máxima, el contenedor aumenta el número de depósitos y vuelve a generar 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 de la secuencia que controla a través de un objeto de asignador almacenado de tipounordered_set::allocator_type. Este tipo de objeto de asignador debe tener la misma interfaz externa como un objeto de clase de plantillaallocator. Tenga en cuenta que el objeto de asignador almacenado no se copia cuando se asigna el objeto contenedor.

Encabezado:<unordered_set></unordered_set>

Espacio de nombres: std

El tipo de un asignador para administrar el almacenamiento.

typedef Alloc allocator_type;  

Comentarios

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

Ejemplo

Â

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

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

ParámetroDescripción
nbucketNú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ósitonbucket (o justo después del final de un depósito de 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]  
  

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 actualmente correspondiente al valor de clavekeyval.

Ejemplo

Â

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

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_tr1__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  

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 devuelve el tamaño del número de depósitonbucket.

Ejemplo

Â

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

Devuelve unconst iterador que direcciona el primer elemento del intervalo.

const_iterator cbegin() const;

Valor devuelto

Unconst iterador 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 decbegin, no se puede modificar los elementos del intervalo.

Puede utilizar esta función miembro en lugar de labegin() función miembro para garantizar que el valor devuelto esconst_iterator. Normalmente, se usa junto con elautomática escriba la palabra clave de deducción, tal como se muestra en el ejemplo siguiente. En el ejemplo, considere la posibilidad deContainer sea un modificable (no - const) contenedor de cualquier naturaleza que admitebegin() ycbegin().

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

// i2 isContainer<T>::const_iterator  

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

const_iterator cend() const;

Valor devuelto

Unconst iterador 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.

Puede utilizar esta función miembro en lugar de laend() función miembro para garantizar que el valor devuelto esconst_iterator. Normalmente, se usa junto con elautomática escriba la palabra clave de deducción, tal como se muestra en el ejemplo siguiente. En el ejemplo, considere la posibilidad deContainer sea un modificable (no - const) contenedor de cualquier naturaleza que admiteend() ycend().

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

// i2 isContainer<T>::const_iterator  

El valor devuelto porcend no se debe desreferenciar.

Quita todos los elementos.

void clear();

Comentarios

Las llamadas a funciones miembrounordered_set::erase ( unordered_set::begin (), unordered_set::end()).

Ejemplo

Â

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

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. Se describe aquí como un sinónimo del tipo definido por la implementaciónT1.

Ejemplo

Â

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

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. Se describe aquí como un sinónimo del tipo definido por la implementaciónT5.

Ejemplo

Â

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

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

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

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 del intervalo delimitado porunordered_set::equal_range(keyval).

Ejemplo

Â

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

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. Se describe aquí como un sinónimo del tipo definido por la implementaciónT3.

Ejemplo

Â

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

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

ParámetroDescripción
argsArgumentos reenviados para construir un elemento que se va a insertar en el unordered_set, a menos que ya contenga un elemento cuyo valor esté ordenado de forma equivalente.

Valor devuelto

Unpair cuyobool componente devuelve true si se realizó una inserción y false si elunordered_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 insertó un nuevo elemento o donde ya se encuentra el elemento.

Para tener acceso al componente de iterador de un parpr devuelto por esta función miembro, utilicepr.firsty para desreferenciarlo, utilice*(pr.first). Para tener acceso a labool componente de un parpr devuelto por esta función miembro, utilicepr.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, consulteset::emplace.

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

ParámetroDescripción
argsArgumentos reenviados para construir un elemento que se va a insertar en el unordered_set a menos que el unordered_set ya contenga ese elemento o, más en general, a menos que ya contenga un elemento cuya clave esté ordenada de manera equivalente.
whereSugerencia con respecto al lugar donde se va a 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.

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, consulteset::emplace_hint.

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_tr1__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  

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

ParámetroDescripción
nbucketNú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 justo después del final del depósitonbucket.

Ejemplo

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

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 iteradoresX que[X.first, X.second) delimita los elementos de la secuencia controlada que tengan una ordenación equivalente conkeyval. Si no existen estos elementos, los iteradores sonend().

Ejemplo

Â

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

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

 
iterator erase(const_iteratorWhere);

iterator erase(
const_iteratorFirst, const_iteratorLast);

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

Para 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 de unordered_set si no existe ese elemento.

Para 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, consulteSet:: Erase.

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

Ejemplo

Â

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

Obtiene el objeto de asignador almacenado.

Alloc get_allocator() const;

Comentarios

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

Ejemplo

Â

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

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_tr1__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  

El tipo de la función hash.

typedef Hash hasher;  

Comentarios

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

Ejemplo

Â

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

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

ParámetroDescripción
ValValor de un elemento que se va a insertar en el unordered_set a menos que ya contenga un elemento cuya clave se ordena de forma equivalente.
WhereLugar donde se va a iniciar la búsqueda del punto de inserción correcto.
ValTyParámetro de plantilla que especifica el tipo de argumento que el unordered_set puede utilizar para construir un elemento devalue_typey el reenvío directoVal como argumento.
FirstPosición del primer elemento que se va a copiar.
LastPosición situada más allá del último elemento que se va a copiar.
InputIteratorArgumento de función de plantilla que cumpla los requisitos de uniterador de entrada que apunta a los elementos de un tipo que se puede utilizar para construirvalue_type objetos.
IListElinitializer_list desde el que se va a copiar los elementos.

Valor devuelto

Las funciones de miembro único elemento, (1) y (2), devuelven unpar cuyobool componente es 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. El componente de iterador del par de valor devuelto apunta al elemento recién insertado si elbool componente es true, o al elemento existente si labool componente es false.

Las funciones miembro de 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, 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 unpair``pr devuelto por las funciones miembro de elemento único, usepr.first; para desreferenciar el iterador dentro del par devuelto, utilice*pr.first, especificando un elemento. Para tener acceso a labool componente, usepr.second. Para obtener un ejemplo, vea el código de ejemplo que se muestra más adelante en este artículo.

Elvalue_type de un contenedor es un typedef que pertenece al contenedor y, en conjunto, unordered_set<V>::value_type es de tipoconst V.

La función de miembro de intervalo (5) inserta la secuencia de valores de elemento en un unordered_set que corresponde a cada elemento direccionado por un iterador en el intervalo de[First, Last); por lo tanto, Last no se inserta. La función de miembro de contenedorend() hace referencia a la posición situada justo después del último elemento de la € containerâ "por ejemplo, la instruccións.insert(v.begin(), v.end()); intenta insertar todos los elementos dev ens. 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 elemento único deinsert.

La lista función miembro inicializadores (6) utiliza uninitializer_list para copiar elementos en el unordered_set.

Inserción de un elemento construido en place†", es decir, ninguna operación de copiar o mover es performedâ€" veaset::emplace yset::emplace_hint.

Para obtener un ejemplo de código, consulteSet:: Insert.

Un tipo que proporciona una constanteiterador hacia delante que puede leer elementos en un unordered_set.

typedef implementation-defined iterator;  

Ejemplo

Vea el ejemplo decomenzar para obtener un ejemplo de cómo declarar y utilizar unaiterador.

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_tr1__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  

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

typedef Pred key_equal;  

Comentarios

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

Ejemplo

Â

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

El tipo de una clave de ordenación.

typedef Key key_type;  

Comentarios

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

Ejemplo

Â

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

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_tr1__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  

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. Se describe aquí como un sinónimo del tipo definido por la implementaciónT4.

Ejemplo

Â

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

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_tr1__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  

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

Ejemplo

Â

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

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_tr1__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  

Copia una tabla hash.

 
unordered_set& operator=(const unordered_set& right);

unordered_set& operator=(unordered_set&& right);

Parámetros

ParámetroDescripción
rightElunordered_set se copian en elunordered_set.

Comentarios

Después de borrar todos los elementos existentes en unaunordered_set, operator= copia o mueve el contenido deright en elunordered_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;  
}  
  

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

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

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 sea al menosnbuckets y vuelve a generar la tabla hash según sea necesario.

Ejemplo

Â

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

Cuenta el número de elementos.

size_type size() const;

Comentarios

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

Ejemplo

Â

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

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. Se describe aquí como un sinónimo del tipo definido por la implementaciónT2.

Ejemplo

Â

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

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 yright. Siunordered_set::get_allocator() == right.get_allocator(), lo hace en tiempo constante, se produce una excepción sólo como resultado de copiar el objeto almacenado rasgos de tipoTr, y se invalida ningún referencias, punteros o iteradores que designan los elementos de 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_tr1__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]  
  

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

ParámetroDescripción
InputIteratorTipo de iterador.
AlObjeto de asignador que se va a almacenar.
CompObjeto de función de comparación que se va a almacenar.
HashObjeto de función hash que se va a almacenar.
bucket_countNúmero mínimo de depósitos.
RightContenedor que se va a copiar.
IListinitializer_list que contiene los elementos que se van a copiar.

Comentarios

El primer constructor especifica una copia de la secuencia controlada porRight. El segundo constructor especifica una secuencia controlada vacía. El tercer constructor especifica una copia de la secuencia moviendoRight lo constructores cuarto a octavo utilizan una initializer_list para especificar los elementos que se va 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 desdeRight. De lo contrario:

El número mínimo de depósitos es el argumentobucket_count, si está presente; en caso contrario, es un valor predeterminado descrito aquí como el valor definido por la implementaciónN0.

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

El objeto de función de comparación es el argumentoComp, si está presente; de lo contrario esComp().

El objeto de asignador es el argumentoAl, si está presente; en caso contrario, esAlloc().

El tipo de un elemento.

typedef Key value_type;  

Comentarios

El tipo describe un elemento de la secuencia controlada.

Ejemplo

Â

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

<unordered_set> </unordered_set>
Contenedores
Seguridad para subprocesos en la biblioteca estándar de C++
Biblioteca de plantillas estándar

Mostrar: