hash_set (Clase)

 

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

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

La clase de contenedor hash_set es una extensión de la biblioteca de plantillas estándar (STL) y se usa para el almacenamiento y la recuperación rápida de datos de una colección en la que los valores de los elementos contenidos son únicos y actúan como valores clave.

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

Parámetros

Key
Tipo de datos de elemento que se almacenará en hash_set.

Traits
Tipo que incluye dos objetos de función, uno de clase compare que es un predicado binario puede comparar dos valores de elemento como claves de ordenación para determinar su orden relativo y una función hash que es un predicado unario que asigna valores de clave de los elementos a enteros sin signo de tipo size_t. Este argumento es opcional y el hash_compare * <> * menos * <> </> > > * es el valor predeterminado.

Allocator
Tipo que representa el objeto de asignador almacenado que encapsula los detalles sobre la asignación y desasignación de memoria de hash_set. Este argumento es opcional y el valor predeterminado es asignador<>>.

El hash_set es:

  • Un contenedor asociativo de tamaño variable que admite la recuperación eficaz de valores de elemento según un valor de clave asociado. Es más, es un contenedor asociativo simple porque los valores de elemento son sus valores de clave.

  • Reversible, porque proporciona un iterador bidireccional para tener acceso a sus elementos.

  • Con algoritmo hash, ya que sus elementos se agrupan en depósitos en función del valor de una función hash aplicada a los valores de clave de los elementos.

  • Único en el sentido de que cada uno de sus elementos debe tener una clave única. Puesto que hash_set también es un contenedor asociativo simple, sus elementos también son únicos.

  • Una clase de plantilla, porque la funcionalidad que proporciona es genérica y, por tanto, independiente del tipo específico de datos contenido como elementos o claves. Los tipos de datos que se usarán para los elementos y las claves se especifican como parámetros en la plantilla de clase junto con la función de comparación y el asignador.

La ventaja principal de los algoritmos hash sobre la ordenación es su mayor eficacia; un algoritmo hash que se ejecuta correctamente realiza inserciones, eliminaciones y búsquedas en un tiempo promedio constante en comparación con un tiempo proporcional al logaritmo del número de elementos del contenedor en el caso de las técnicas de ordenación. El valor de un elemento de un conjunto no se puede cambiar directamente. Lo que se debe hacer es eliminar los valores antiguos e insertar elementos con nuevos valores.

En general, la elección del tipo de contenedor se debe tomar según el tipo de búsqueda y de inserción que necesite la aplicación. Los contenedores asociativos con algoritmo hash están optimizados para las operaciones de búsqueda, inserción y eliminación. Las funciones miembro que admiten explícitamente estas operaciones son eficaces cuando se usan con una función hash bien diseñada, las realizan en un tiempo que es una constante promedio y no dependen del número de elementos del contenedor. Una función hash bien diseñada genera una distribución uniforme de valores hash y minimiza el número de colisiones; se produce una colisión cuando se asignan valores de clave distintos al mismo valor hash. En el peor de los casos, con la peor función hash posible, el número de operaciones es proporcional al número de elementos de la secuencia (tiempo lineal).

El hash_set debe ser el contenedor asociativo preferido cuando la aplicación cumpla las condiciones que asocian los valores a sus claves. Los elementos de un hash_set son únicos y actúan como sus propios criterios de ordenación. Un modelo para este tipo de estructura es una lista ordenada, por ejemplo, de palabras en las que las palabras pueden aparecer solo una vez. Si se permiten varias repeticiones de las palabras, la estructura de contenedor adecuada sería hash_multiset. Si los valores necesitan estar asociados a una lista de palabras clave únicas, un hash_map sería una estructura adecuada para contener estos datos. Si, por el contrario, las claves no son únicas, un hash_multimap sería el contenedor preferido.

El hash_set ordena la secuencia que controla llamando a un hash almacenado rasgos objeto de tipo value_compare. Puede obtenerse acceso a este objeto almacenado llamando a la función miembro key_comp. Este tipo de objeto de función debe comportarse igual que un objeto de clase hash_compare<Key,> </Key,> <> </> > >. Concretamente, para todos los valores de key de clave, la llamada rasgo de tipo ( key ) produce una distribución de valores de tipo size_t.

En general, se debe poder comparar si los elementos son menores que otros para poder establecer este orden; de este modo, dados dos elementos cualesquiera, se puede determinar que son equivalentes (en el sentido de que ninguno es menor que el otro) o que uno es menor que el otro. Esto produce una ordenación entre los elementos no equivalentes. En un sentido más técnico, la función de comparación es un predicado binario que induce una ordenación débil estricta en el sentido matemático estándar. Un predicado binario f( x, y) es un objeto de función que tiene dos objetos de argumento x y y y un valor devuelto de true o false. Una ordenación impuesta en hash_set es una ordenación débil estricta si el predicado binario es Irreflexivo, antisimétrico y transitivo, y si la equivalencia es transitiva, donde dos objetos x y y se definen como equivalentes cuando tanto f( x, y) y f( y, x) son false. Si la condición más fuerte de igualdad entre las claves reemplaza la de equivalencia, la ordenación se convierte en total (en el sentido de que todos los elementos se ordenan entre sí) y las claves coincidentes serán indiscernibles unas de otras.

El orden real de los elementos de la secuencia controlada depende de la función hash, la función de ordenación y el tamaño actual de la tabla hash almacenada en el objeto contenedor. No se puede determinar el tamaño actual de la tabla hash, por lo que en general no se puede predecir el orden de los elementos de la secuencia controlada. La inserción de elementos no invalida ningún iterador y al quitar elementos solo se invalidan los iteradores que habían apuntado específicamente a los elementos quitados.

El iterador proporcionado por hash_set (clase) es un iterador bidireccional, pero las funciones de miembro de clase insertar y hash_set tienen versiones que toman como parámetros de plantilla un iterador de entrada más débil, cuyos requisitos de funcionalidad son más mínimos que los garantizados por la clase de iteradores bidireccionales. Los distintos conceptos de iterador forman una familia relacionada por los refinamientos de su funcionalidad. Cada concepto de iterador tiene su propio conjunto de requisitos, y los algoritmos que funcionan con ellos deben limitar sus suposiciones a los requisitos proporcionados por ese tipo de iterador. Se puede suponer que se puede desreferenciar un iterador de entrada para hacer referencia a un objeto y que se puede incrementar hasta el iterador siguiente de la secuencia. Se trata de un conjunto mínimo de funcionalidad, pero es suficiente para poder comunicarse sobre un intervalo de iteradores [ first, last) en el contexto de las funciones miembro de clase.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Constructores

hash_setConstruye un hash_set que está vacío o que es una copia de todo o de parte de otro hash_set.

Definiciones de tipo

allocator_typeTipo que representa la clase allocator para el objeto hash_set.
const_iteratorTipo que proporciona un iterador bidireccional que puede leer un elemento const en hash_set.
const_pointerTipo que proporciona un puntero a un elemento const en un hash_set.
const_referenceTipo que proporciona una referencia a un elemento const almacenado en un hash_set para leer y realizar operaciones const.
const_reverse_iteratorTipo que proporciona un iterador bidireccional que puede leer cualquier elemento const en hash_set.
difference_typeTipo entero con signo que se puede usar para representar el número de elementos de un hash_set en un intervalo entre elementos a los que apuntan los iteradores.
iteradorTipo que proporciona un iterador bidireccional que puede leer o modificar cualquier elemento de hash_set.
key_compareTipo que proporciona un objeto de función que puede comparar dos claves de ordenación para determinar el orden relativo de dos elementos en el hash_set.
KEY_TYPETipo que describe un objeto almacenado como un elemento de un hash_set en su capacidad como criterio de ordenación.
punteroTipo que proporciona un puntero a un elemento de hash_set.
referenciaTipo que proporciona una referencia a un elemento almacenado en un hash_set.
reverse_iteratorTipo que proporciona un iterador bidireccional que puede leer o modificar un elemento de hash_set invertido.
size_typeTipo entero sin signo que puede representar el número de elementos de un hash_set.
value_compareTipo que proporciona dos objetos de función, un predicado binario de la clase compare que puede comparar dos valores de elementos de un hash_set para determinar su orden relativo y un predicado unario que aplica un algoritmo hash a los elementos.
value_typeTipo que describe un objeto almacenado como un elemento de un hash_set en su capacidad como valor.

Funciones miembro

comenzarDevuelve un iterador que direcciona el primer elemento del hash_set.
hash_set::cbeginDevuelve un iterador constante que direcciona el primer elemento del hash_set.
hash_set::cendDevuelve un iterador constante que direcciona la ubicación que sigue al último elemento de hash_set.
BorrarBorra todos los elementos de un hash_set.
recuentoDevuelve el número de elementos de un hash_set cuya clave coincide con una clave especificada por un parámetro.
hash_set::crbeginDevuelve un iterador constante que direcciona el primer elemento de hash_set invertido.
hash_set::crendDevuelve un iterador constante que direcciona la ubicación que sigue al último elemento de hash_set invertido.
hash_set::emplaceInserta en un hash_set un elemento construido en contexto.
hash_set::emplace_hintInserta en un hash_set un elemento construido en contexto, con una sugerencia de colocación.
vacíaComprueba si un hash_set está vacío.
finalDevuelve un iterador que direcciona la ubicación que sigue al último elemento de hash_set.
equal_rangeDevuelve un par de iteradores respectivamente al primer elemento de hash_set cuya clave mayor es que una clave especificada y al primer elemento del hash_set cuya clave es igual o mayor que la clave especificada.
BorrarQuita un elemento o un intervalo de elementos de una clase hash_set de las posiciones especificadas o quita los elementos que coinciden con una clave especificada.
BuscarDevuelve un iterador que direcciona la ubicación de un elemento en un hash_set que tiene una clave equivalente a una clave especificada.
get_allocatorDevuelve una copia del objeto allocator utilizado para construir el hash_set.
InsertarInserta un elemento o un intervalo de elementos en un hash_set.
key_compRecupera una copia del objeto de comparación utilizado para ordenar claves de un hash_set.
lower_boundDevuelve un iterador al primer elemento de un hash_set cuya clave es igual o mayor que una clave especificada.
max_sizeDevuelve la longitud máxima del hash_set.
rbeginDevuelve un iterador que direcciona el primer elemento de hash_set invertido.
rendDevuelve un iterador que direcciona la ubicación que sigue al último elemento de hash_set invertido.
tamañoDevuelve el número de elementos de hash_set.
intercambioIntercambia los elementos de dos hash_set.
upper_boundDevuelve un iterador al primer elemento de hash_set cuyo valor de clave es igual o mayor que el de una clave especificada.
value_compRecupera una copia del objeto traits hash usado para aplicar un algoritmo hash y ordenar valores de claves de elementos en un hash_set.

Operadores

hash_set::operator =Reemplaza los elementos de un hash_set con una copia de otro hash_set.

Encabezado:<hash_set></hash_set>

Espacio de nombres: stdext

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Tipo que representa la clase de asignador del objeto hash_set.

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

Comentarios

allocator_type es un sinónimo del parámetro de plantilla Allocator.

Para obtener más información sobre Allocator, vea la sección Comentarios de la hash_set (clase) tema.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

Vea el ejemplo para get_allocator para obtener un ejemplo que usa allocator_type.

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve un iterador que direcciona el primer elemento de la hash_set.

const_iterator begin() const;

iterator begin();

Valor devuelto

Iterador bidireccional que direcciona el primer elemento en el hash_set o la ubicación que sigue un hash_set vacía.

Comentarios

Si el valor devuelto de comenzar se asigna a un const_iterator, no se puede modificar los elementos en el objeto hash_set. Si el valor devuelto de comenzar se asigna a un iterador, se pueden modificar los elementos en el objeto hash_set.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_begin.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
   hash_set <int>::iterator hs1_Iter;  
   hash_set <int>::const_iterator hs1_cIter;  
  
   hs1.insert( 1 );  
   hs1.insert( 2 );  
   hs1.insert( 3 );  
  
   hs1_Iter = hs1.begin( );  
   cout << "The first element of hs1 is " << *hs1_Iter << endl;  
  
   hs1_Iter = hs1.begin( );  
   hs1.erase( hs1_Iter );  
  
   // The following 2 lines would err because the iterator is const  
   // hs1_cIter = hs1.begin( );  
   // hs1.erase( hs1_cIter );  
  
   hs1_cIter = hs1.begin( );  
   cout << "The first element of hs1 is now " << *hs1_cIter << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve un iterador const que direcciona el primer elemento de la hash_set.

const_iterator cbegin() const;

Valor devuelto

Iterador bidireccional const que direcciona el primer elemento de la hash_set o la ubicación que sigue vacía hash_set.

Comentarios

Con el valor devuelto de cbegin, los elementos de la hash_set no se puede modificar el objeto.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_cbegin.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
   hash_set <int>::const_iterator hs1_cIter;  
  
   hs1.insert( 1 );  
   hs1.insert( 2 );  
   hs1.insert( 3 );  
  
   hs1_cIter = hs1.cbegin( );  
   cout << "The first element of hs1 is " << *hs1_cIter << endl;  
}  

The first element of hs1 is 1  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve un iterador const que direcciona la ubicación del último elemento de hash_set.

const_iterator cend() const;

Valor devuelto

Iterador bidireccional const que direcciona la ubicación del último elemento de un hash_set. Si el hash_set está vacío, hash_set::cend == hash_set::begin.

Comentarios

cendse utiliza para probar si un iterador ha llegado al final de su hash_set. El valor devuelto por cend no se debe desreferenciar.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_cend.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
   hash_set <int> :: const_iterator hs1_cIter;  
  
   hs1.insert( 1 );  
   hs1.insert( 2 );  
   hs1.insert( 3 );  
  
   hs1_cIter = hs1.cend( );  
   hs1_cIter--;  
   cout << "The last element of hs1 is " << *hs1_cIter << endl;  
}  

The last element of hs1 is 3  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Borra todos los elementos de hash_set.

void clear();

Comentarios

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_clear.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
  
   hs1.insert( 1 );  
   hs1.insert( 2 );  
  
   cout << "The size of the hash_set is initially " << hs1.size( )  
        << "." << endl;  
  
   hs1.clear( );  
   cout << "The size of the hash_set after clearing is "   
        << hs1.size( ) << "." << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Un tipo que proporciona un iterador bidireccional que puede leer una const elemento de la hash_set.

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

Comentarios

Un tipo const_iterator no se puede utilizar para modificar el valor de un elemento.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

Vea el ejemplo para comenzar para obtener un ejemplo que usa const_iterator.

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Un tipo que proporciona un puntero a un const elemento hash_set.

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

Comentarios

Un tipo const_pointer no se puede utilizar para modificar el valor de un elemento.

En la mayoría de los casos, un const_iterator debe utilizarse para tener acceso a los elementos de un const objeto hash_set.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Un tipo que proporciona una referencia a un const elemento almacenado en hash_set para leer y realizar const operaciones.

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

Comentarios

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_const_ref.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
  
   hs1.insert( 10 );  
   hs1.insert( 20 );  
  
   // Declare and initialize a const_reference &Ref1   
   // to the 1st element  
   const int &Ref1 = *hs1.begin( );  
  
   cout << "The first element in the hash_set is "  
        << Ref1 << "." << endl;  
  
   // The following line would cause an error because the   
   // const_reference cannot be used to modify the hash_set  
   // Ref1 = Ref1 + 5;  
}  

The first element in the hash_set is 10.  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Un tipo que proporciona un iterador bidireccional que puede lee cualquier const elemento de la hash_set.

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

Comentarios

Un tipo de const_reverse_iterator no se puede modificar el valor de un elemento y se utiliza para recorrer en iteración el hash_set en orden inverso.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

Vea el ejemplo de rend para obtener un ejemplo de cómo declarar y utilizar laconst_reverse_iterator

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve el número de elementos de un objeto hash_set cuya clave coincide con una clave especificada por un parámetro.

size_type count(const Key& key) const;

Parámetros

key
La clave de los elementos cuya coincidencia debe buscarse a partir del objeto hash_set.

Valor devuelto

Es&1; si el objeto hash_set contiene un elemento cuyo criterio de ordenación coincide con la clave de parámetro.

Es&0; si el objeto hash_set no contiene ningún elemento con una clave coincidente.

Comentarios

La función miembro devuelve el número de elementos del intervalo siguiente:

[ lower_bound (_ Key ), upper_bound (_ Key ) ).

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

El ejemplo siguiente muestra cómo debe usarse la función miembro hash_set::count.

// hash_set_count.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
    using namespace std;  
    using namespace stdext;  
    hash_set<int> hs1;  
    hash_set<int>::size_type i;  
  
    hs1.insert(1);  
    hs1.insert(1);  
  
    // Keys must be unique in hash_set, so duplicates are ignored.  
    i = hs1.count(1);  
    cout << "The number of elements in hs1 with a sort key of 1 is: "  
         << i << "." << endl;  
  
    i = hs1.count(2);  
    cout << "The number of elements in hs1 with a sort key of 2 is: "  
         << i << "." << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve un iterador const que direcciona el primer elemento en hash_set invertida.

const_reverse_iterator crbegin() const;

Valor devuelto

Un iterador constante bidireccional inverso dirige al primer elemento en invertido hash_set o direccionamiento lo que habría sido el último elemento de la irreversible hash_set.

Comentarios

crbeginse utiliza con hash_set invertida igual que hash_set:: BEGIN se usa con hash_set.

Con el valor devuelto de crbegin, el objeto hash_set no se puede modificar.

crbeginpuede usarse para recorrer en iteración un hash_set con versiones anteriores.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_crbegin.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
   hash_set <int>::const_reverse_iterator hs1_crIter;  
  
   hs1.insert( 10 );  
   hs1.insert( 20 );  
   hs1.insert( 30 );  
  
   hs1_crIter = hs1.crbegin( );  
   cout << "The first element in the reversed hash_set is "  
        << *hs1_crIter << "." << endl;  
}  

The first element in the reversed hash_set is 30.  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve un iterador const que direcciona la ubicación del último elemento de hash_set invertida.

const_reverse_iterator crend() const;

Valor devuelto

Un iterador constante bidireccional inverso que direcciona la ubicación del último elemento de invertido hash_set (la ubicación que había precedido al primer elemento de la irreversible hash_set).

Comentarios

crendse utiliza con invertido hash_set como hash_set:: end se usa con un hash_set.

Con el valor devuelto de crend, el objeto hash_set no se puede modificar.

Se puede utilizar crend para comprobar si un iterador inverso llegó al final de su hash_set.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_crend.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
   hash_set <int>::const_reverse_iterator hs1_crIter;  
  
   hs1.insert( 10 );  
   hs1.insert( 20 );  
   hs1.insert( 30 );  
  
   hs1_crIter = hs1.crend( );  
   hs1_crIter--;  
   cout << "The last element in the reversed hash_set is "  
        << *hs1_crIter << "." << endl;  
}  

The last element in the reversed hash_set is 10.  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Tipo de entero con signo que puede utilizarse para representar el número de elementos de hash_set en un intervalo entre elementos que apuntan los iteradores.

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

Comentarios

El difference_type es el tipo devuelto al restar o incrementar los iteradores del contenedor. El difference_type normalmente se utiliza para representar el número de elementos del intervalo [ first, last) entre los iteradores first y last, incluye el elemento al que apunta first y el intervalo de elementos hasta, pero sin incluir, el elemento al que apunta last.

Tenga en cuenta que, aunque difference_type está disponible para todos los iteradores que cumplen los requisitos de un iterador de entrada, que incluye la clase de iteradores bidireccionales admitida por los contenedores reversibles como set, resta entre iteradores solo es compatible con los iteradores de acceso aleatorio proporcionados por un contenedor de acceso aleatorio, como vector, deque.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_diff_type.cpp  
// compile with: /EHsc  
#include <iostream>  
#include <hash_set>  
#include <algorithm>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
  
   hash_set <int> hs1;  
   hash_set <int>::iterator hs1_Iter, hs1_bIter, hs1_eIter;  
  
   hs1.insert( 20 );  
   hs1.insert( 10 );  
   hs1.insert( 20 );   // Won't insert as hash_set elements are unique  
  
   hs1_bIter = hs1.begin( );  
   hs1_eIter = hs1.end( );  
  
   hash_set <int>::difference_type   df_typ5, df_typ10, df_typ20;  
  
   df_typ5 = count( hs1_bIter, hs1_eIter, 5 );  
   df_typ10 = count( hs1_bIter, hs1_eIter, 10 );  
   df_typ20 = count( hs1_bIter, hs1_eIter, 20 );  
  
   // The keys, and hence the elements, of a hash_set are unique,  
   // so there is at most one of a given value  
   cout << "The number '5' occurs " << df_typ5  
        << " times in hash_set hs1.\n";  
   cout << "The number '10' occurs " << df_typ10  
        << " times in hash_set hs1.\n";  
   cout << "The number '20' occurs " << df_typ20  
        << " times in hash_set hs1.\n";  
  
   // Count the number of elements in a hash_set  
   hash_set <int>::difference_type  df_count = 0;  
   hs1_Iter = hs1.begin( );  
   while ( hs1_Iter != hs1_eIter)  
   {  
      df_count++;  
      hs1_Iter++;  
   }  
  
   cout << "The number of elements in the hash_set hs1 is: "   
        << df_count << "." << endl;  
}  

The number '5' occurs 0 times in hash_set hs1.  
The number '10' occurs 1 times in hash_set hs1.  
The number '20' occurs 1 times in hash_set hs1.  
The number of elements in the hash_set hs1 is: 2.  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Inserta un elemento construido en contexto hash_set.

template <class ValTy>  
pair <iterator, bool>  
emplace(
    ValTy&& val);

Parámetros

ParámetroDescripción
valEl valor de un elemento que se va a insertar en el hash_set a menos que el hash_set ya contenga ese elemento o, por lo general, un elemento cuya clave se ordena.

Valor devuelto

El emplace función miembro devuelve un par cuyo bool componente devuelve true si se hizo una inserción y false si el hash_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.

Comentarios

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_emplace.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
#include <string>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set<string> hs3;  
   string str1("a");  
  
   hs3.emplace(move(str1));  
   cout << "After the emplace insertion, hs3 contains "  
      << *hs3.begin() << "." << endl;  
}  

After the emplace insertion, hs3 contains a.  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Inserta un elemento construido en contexto hash_set.

template <class ValTy>  
iterator emplace(
    const_iterator _Where,  
    ValTy&& val);

Parámetros

ParámetroDescripción
valEl valor de un elemento que se va a insertar en el hash_set a menos que el hash_set ya contenga ese elemento o, por lo general, un elemento cuya clave se ordena.
_WhereLugar donde se va a iniciar la búsqueda del punto de inserción correcto. (La inserción se puede realizar en tiempo constante amortizado, en lugar de en tiempo logarítmico, si el punto de inserción sigue inmediatamente a _Where).

Valor devuelto

El hash_set::emplace función miembro devuelve un iterador que apunta a la posición donde se insertó el nuevo elemento en el hash_set, o donde se encuentra el elemento existente con una ordenación equivalente.

Comentarios

Inserción se puede realizar en tiempo constante amortizado, en lugar de tiempo logarítmico, si el punto de inserción sigue inmediatamente a _Where.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_emplace_hint.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
#include <string>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set<string> hs3;  
   string str1("a");  
  
   hs3.insert(hs3.begin(), move(str1));  
   cout << "After the emplace insertion, hs3 contains "  
      << *hs3.begin() << "." << endl;  
}  

After the emplace insertion, hs3 contains a.  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Comprueba si hash_set está vacío.

bool empty() const;

Valor devuelto

True si el hash_set está vacía. false si el hash_set no está vacía.

Comentarios

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_empty.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1, hs2;  
   hs1.insert ( 1 );  
  
   if ( hs1.empty( ) )  
      cout << "The hash_set hs1 is empty." << endl;  
   else  
      cout << "The hash_set hs1 is not empty." << endl;  
  
   if ( hs2.empty( ) )  
      cout << "The hash_set hs2 is empty." << endl;  
   else  
      cout << "The hash_set hs2 is not empty." << endl;  
}  

The hash_set hs1 is not empty.  
The hash_set hs2 is empty.  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve un iterador que direcciona la ubicación del último elemento de hash_set.

const_iterator end() const;

iterator end();

Valor devuelto

Iterador bidireccional que direcciona la ubicación del último elemento de hash_set. Si el hash_set está vacío, hash_set:: end == hash_set:: begin.

Comentarios

end se utiliza para probar si un iterador ha llegado al final de su hash_set. El valor devuelto por final no se debe desreferenciar.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_end.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
   hash_set <int> :: iterator hs1_Iter;  
   hash_set <int> :: const_iterator hs1_cIter;  
  
   hs1.insert( 1 );  
   hs1.insert( 2 );  
   hs1.insert( 3 );  
  
   hs1_Iter = hs1.end( );  
   hs1_Iter--;  
   cout << "The last element of hs1 is " << *hs1_Iter << endl;  
  
   hs1.erase( hs1_Iter );  
  
   // The following 3 lines would err because the iterator is const:  
   // hs1_cIter = hs1.end( );  
   // hs1_cIter--;  
   // hs1.erase( hs1_cIter );  
  
   hs1_cIter = hs1.end( );  
   hs1_cIter--;  
   cout << "The last element of hs1 is now " << *hs1_cIter << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve un par de iteradores, respectivamente para el primer elemento de un conjunto con una clave que es igual a una clave especificada y hasta el primer elemento en el conjunto con una clave que es mayor que la clave hash de hash.

pair <const_iterator, const_iterator> equal_range (const Key& key) const;

pair <iterator, iterator> equal_range (const Key& key);

Parámetros

key
Clave de argumento que se va a comparar con el criterio de ordenación de un elemento de la hash_set buscada.

Valor devuelto

Un par de iteradores donde el primero es el lower_bound de la clave y el segundo es el upper_bound de la clave.

Para obtener acceso el primer iterador de un pr par devuelto por la función miembro, utilice pr. primeray para desreferenciar el iterador de límite inferior, utilice *( pr. en primer lugar). Para tener acceso el iterador de segundo de un par pr devuelto por la función miembro, utilice pr. segundoy para desreferenciar el iterador de límite superior, use *( pr. en segundo lugar).

Comentarios

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_equal_range.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;   
   using namespace stdext;  
   typedef hash_set<int> IntHSet;  
   IntHSet hs1;  
   hash_set <int> :: const_iterator hs1_RcIter;  
  
   hs1.insert( 10 );  
   hs1.insert( 20 );  
   hs1.insert( 30 );  
  
   pair <IntHSet::const_iterator, IntHSet::const_iterator> p1, p2;  
   p1 = hs1.equal_range( 20 );  
  
   cout << "The upper bound of the element with "  
        << "a key of 20 in the hash_set hs1 is: "  
        << *(p1.second) << "." << endl;  
  
   cout << "The lower bound of the element with "  
        << "a key of 20 in the hash_set hs1 is: "  
        << *(p1.first) << "." << endl;  
  
   // Compare the upper_bound called directly   
   hs1_RcIter = hs1.upper_bound( 20 );  
   cout << "A direct call of upper_bound( 20 ) gives "  
        << *hs1_RcIter << "," << endl  
        << "matching the 2nd element of the pair"  
        << " returned by equal_range( 20 )." << endl;  
  
   p2 = hs1.equal_range( 40 );  
  
   // If no match is found for the key,  
   // both elements of the pair return end( )  
   if ( ( p2.first == hs1.end( ) ) && ( p2.second == hs1.end( ) ) )  
      cout << "The hash_set hs1 doesn't have an element "  
           << "with a key greater than or equal to 40." << endl;  
   else  
      cout << "The element of hash_set hs1 with a key >= 40 is: "  
           << *(p1.first) << "." << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

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

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Parámetros

_Where
Posición del elemento que se quita del hash_set.

first
Posición del primer elemento que se quita del hash_set.

last
Posición inmediatamente siguiente al último elemento que se quita del hash_set.

key
Clave de los elementos que se van a quitar del hash_set.

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 puntero al final del hash_set si no existe ese elemento. Para la tercera función miembro, el número de elementos que se han quitado del hash_set.

Comentarios

Las funciones miembro nunca producen una excepción.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

En el ejemplo siguiente se muestra el uso de la función miembro hash_set::erase.

// hash_set_erase.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main()  
{  
    using namespace std;  
    using namespace stdext;  
    hash_set<int> hs1, hs2, hs3;  
    hash_set<int>::iterator pIter, Iter1, Iter2;  
    int i;  
    hash_set<int>::size_type n;  
  
    for (i = 1; i < 5; i++)  
    {  
        hs1.insert (i);  
        hs2.insert (i * i);  
        hs3.insert (i - 1);  
    }  
  
    // The 1st member function removes an element at a given position  
    Iter1 = ++hs1.begin();  
    hs1.erase(Iter1);  
  
    cout << "After the 2nd element is deleted, the hash_set hs1 is:";  
    for (pIter = hs1.begin(); pIter != hs1.end(); pIter++)  
        cout << " " << *pIter;  
    cout << "." << endl;  
  
    // The 2nd member function removes elements  
    // in the range [ first,  last)  
    Iter1 = ++hs2.begin();  
    Iter2 = --hs2.end();  
    hs2.erase(Iter1, Iter2);  
  
    cout << "After the middle two elements are deleted, "  
         << "the hash_set hs2 is:";  
    for (pIter = hs2.begin(); pIter != hs2.end(); pIter++)  
        cout << " " << *pIter;  
    cout << "." << endl;  
  
    // The 3rd member function removes elements with a given  key  
    n = hs3.erase(2);  
  
    cout << "After the element with a key of 2 is deleted, "  
         << "the hash_set hs3 is:";  
    for (pIter = hs3.begin(); pIter != hs3.end(); pIter++)  
        cout << " " << *pIter;  
    cout << "." << endl;  
  
    // The 3rd member function returns the number of elements removed  
    cout << "The number of elements removed from hs3 is: "  
         << n << "." << endl;  
  
    // The dereferenced iterator can also be used to specify a key  
    Iter1 = ++hs3.begin();  
    hs3.erase(Iter1);  
  
    cout << "After another element (unique for hash_set) with a key "  
         << endl;  
    cout  << "equal to that of the 2nd element is deleted, "  
          << "the hash_set hs3 is:";  
    for (pIter = hs3.begin(); pIter != hs3.end(); pIter++)  
        cout << " " << *pIter;  
    cout << "." << endl;  
}  

After the 2nd element is deleted, the hash_set hs1 is: 1 3 4.  
After the middle two elements are deleted, the hash_set hs2 is: 16 4.  
After the element with a key of 2 is deleted, the hash_set hs3 is: 0 1 3.  
The number of elements removed from hs3 is: 1.  
After another element (unique for hash_set) with a key   
equal to that of the 2nd element is deleted, the hash_set hs3 is: 0 3.  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve un iterador que direcciona la ubicación de un elemento de hash_set que tiene una clave equivalente a una clave especificada.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parámetros

key
La clave de argumento que debe coincidir con el criterio de ordenación de un elemento de la hash_set buscada.

Valor devuelto

Un iterador o const_iterator que dirige a la ubicación de un elemento equivalente a una clave especificada o que direcciona la ubicación del último elemento de la hash_set si se encuentra ninguna coincidencia para la clave.

Comentarios

La función miembro devuelve un iterador que direcciona la hash_set cuyo criterio de ordenación es un elemento equivalente al argumento de clave de un predicado binario que induce una ordenación basada en un menor-que la relación de comparabilidad.

Si el valor devuelto de buscar se asigna a un const_iterator, no se puede modificar el objeto hash_set. Si el valor devuelto de buscar se asigna a un iterador, el objeto hash_set puede modificarse.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_find.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;  
  
   hs1.insert( 10 );  
   hs1.insert( 20 );  
   hs1.insert( 30 );  
  
   hs1_RcIter = hs1.find( 20 );  
   cout << "The element of hash_set hs1 with a key of 20 is: "  
        << *hs1_RcIter << "." << endl;  
  
   hs1_RcIter = hs1.find( 40 );  
  
   // If no match is found for the key, end( ) is returned  
   if ( hs1_RcIter == hs1.end( ) )  
      cout << "The hash_set hs1 doesn't have an element "  
           << "with a key of 40." << endl;  
   else  
      cout << "The element of hash_set hs1 with a key of 40 is: "  
           << *hs1_RcIter << "." << endl;  
  
   // The element at a specific location in the hash_set can be found   
   // by using a dereferenced iterator addressing the location  
   hs1_AcIter = hs1.end( );  
   hs1_AcIter--;  
   hs1_RcIter = hs1.find( *hs1_AcIter );  
   cout << "The element of hs1 with a key matching "  
        << "that of the last element is: "  
        << *hs1_RcIter << "." << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve una copia del objeto de asignador utilizado para construir el hash_set.

Allocator get_allocator() const;

Valor devuelto

El asignador utilizado por el hash_set para administrar la memoria, que es el parámetro de plantilla Allocator.

Para obtener más información sobre Allocator, vea la sección Comentarios de la hash_set (clase) tema.

Comentarios

Los asignadores de hash_set (clase) especifican cómo la clase administra el almacenamiento. Los asignadores predeterminados proporcionados con las clases de contenedor STL es suficiente para la mayoría de necesidades de programación. La escritura y el uso de sus propias clases de asignador son temas avanzados de C++.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_get_allocator.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
  
   // The following lines declare objects  
   // that use the default allocator.  
   hash_set <int, hash_compare <int, less<int> > > hs1;  
   hash_set <int,  hash_compare <int, greater<int> > > hs2;  
   hash_set <double, hash_compare <double,  
      less<double> >, allocator<double> > hs3;  
  
   hash_set <int, hash_compare <int,  
      greater<int> > >::allocator_type hs2_Alloc;  
   hash_set <double>::allocator_type hs3_Alloc;  
   hs2_Alloc = hs2.get_allocator( );  
  
   cout << "The number of integers that can be allocated"  
        << endl << "before free memory is exhausted: "  
        << hs1.max_size( ) << "." << endl;  
  
   cout << "The number of doubles that can be allocated"  
        << endl << "before free memory is exhausted: "  
        << hs3.max_size( ) <<  "." << endl;  
  
   // The following lines create a hash_set hs4  
   // with the allocator of hash_set hs1.  
   hash_set <int>::allocator_type hs4_Alloc;  
   hash_set <int> hs4;  
   hs4_Alloc = hs2.get_allocator( );  
  
   // Two allocators are interchangeable if  
   // storage allocated from each can be  
   // deallocated by the other  
   if( hs2_Alloc == hs4_Alloc )  
   {  
      cout << "The allocators are interchangeable."  
           << endl;  
   }  
   else  
   {  
      cout << "The allocators are not interchangeable."  
           << endl;  
   }  
}  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Construye un hash_set que está vacío o que es una copia de todo o de parte de otro hash_set.

hash_set();

explicit hash_set(
    const Traits& Comp);

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

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

hash_set(
    hash_set&& Right);

hash_set(
    initializer_list<Type> IList);

hash_set(
    initializer_list<Type> IList,   
    const Compare& Comp);

hash_set(
    initializer_list<value_type> IList,   
    const Compare& Comp,   
    const Allocator& Al);

template <class InputIterator>  
hash_set(
 InputIterator First,  
    InputIterator Last);

template <class InputIterator>  
hash_set(
 InputIterator First,  
    InputIterator Last,  
    const Traits& Comp);

template <class InputIterator>  
hash_set(
 InputIterator First,  
    InputIterator Last,  
    const Traits& Comp,  
    const Allocator& Al);

Parámetros

ParámetroDescripción
AlClase de asignador de almacenamiento que se va a utilizar para este objeto hash_set, que toma como valor predeterminado Allocator.
CompFunción de comparación de tipo const Traits que se utiliza para ordenar los elementos de hash_set, que toma como valor predeterminado hash_compare.
Righthash_set del que el hash_set construido va a ser una copia.
FirstPosición del primer elemento en el intervalo de elementos que se va a copiar.
LastPosición del primer elemento más allá del intervalo de elementos que se va a copiar.

Comentarios

Todos los constructores almacenan un tipo de objeto de asignador que administra el almacenamiento de memoria para la hash_set y que puede devolver más adelante llamando a hash_set:: get_allocator. El parámetro de asignador se suele omitir en las declaraciones de clase y las macros de preprocesamiento que se utilizan para sustituir asignadores alternativos.

Todos los constructores inicializan sus hash_sets.

Todos los constructores almacenan un objeto de función de tipo Traits que se utiliza para establecer un orden entre las claves de la hash_set y que puede devolver más adelante llamando a hash_set:: key_comp. Para obtener más información sobre Traits ver el hash_set (clase) tema.

El primer constructor crea un inicial vacío hash_set el segundo especifica el tipo de función de comparación ( Comp) que se utilizará para establecer el orden de los elementos y el tercero explícitamente especifica el tipo de asignador ( Al) que se utilizará. La palabra clave explicit suprime ciertas clases de conversión automática de tipos.

Los constructores cuarto y quinto especifican una copia de la hash_set``Right.

Los constructores sexto, séptimo y octavo utilizan una initializer_list para los elementos.

Los últimos constructores copian el intervalo [ First, Last) de un hash_set cada vez más explícita para especificar el tipo de función de comparación de características de clase y el asignador.

El octavo constructor mueve el hash_set``Right.

El orden real de los elementos de un contenedor hash_set depende de la función hash, la función de ordenación y el tamaño actual de la tabla hash y, en general, no se puede predecir como se haría con el contenedor de conjuntos, donde se determina mediante la función de ordenación únicamente.

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Inserta un elemento o un intervalo de elementos en un hash_set.

pair<iterator, bool> insert(
    const value_type& Val);

iterator insert(
    iterator Where,  
    const value_type& Val);

void insert(
    initializer_list<value_type> IList)  
template <class InputIterator>  
void insert(
    InputIterator First,  
    InputIterator Last);

Parámetros

ParámetroDescripción
ValValor de un elemento que se va a insertar en el hash_set a menos que hash_set ya contenga ese elemento o, más general, un elemento cuya clave esté ordenada de manera equivalente.
WhereLugar donde se va a iniciar la búsqueda del punto de inserción correcto. (La inserción se puede realizar en tiempo constante amortizado, en lugar de en tiempo logarítmico, si el punto de inserción sigue inmediatamente a _Where).
FirstPosición del primer elemento que se va a copiar de un hash_set.
LastPosición situada más allá del último elemento que se va a copiar de un hash_set.
IListinitializer_list de la que se van a copiar los elementos.

Valor devuelto

La primera función miembro insert devuelve un par cuyo componente bool devuelve true si se hizo una inserción y false si el hash_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 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 y, para desreferenciarlo, utilice *(pr.second).

La segunda función miembro insert devuelve un iterador que apunta a la posición donde se insertó el nuevo elemento en el hash_set.

Comentarios

La tercera función miembro inserta los elementos en una initializer_list.

La tercera función miembro inserta la secuencia de valores de elemento en un hash_set correspondiente a cada elemento direccionado por un iterador en el intervalo [ First, Last) de un objeto hash_set.

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Un tipo que proporciona un iterador bidireccional que puede leer o modificar cualquier elemento de hash_set.

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

Comentarios

Un tipo de iterador puede utilizarse para modificar el valor de un elemento.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

Vea el ejemplo de comenzar para obtener un ejemplo de cómo declarar y usar iterador.

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Recupera una copia del objeto de rasgos de hash utilizado para hash y ordenar los valores de clave de elemento en hash_set.

key_compare key_comp() const;

Valor devuelto

Devuelve el objeto de función hash_set se utiliza para ordenar sus elementos, que es el parámetro de plantilla Traits.

Para obtener más información sobre Traits ver el hash_set (clase) tema.

Comentarios

El objeto almacenado define la función miembro:

bool operator( const Key& _ xVal, const Key& _ yVal);

que devuelve true si _xVal precede y no es igual a _yVal en el criterio de ordenación.

Tenga en cuenta que ambos key_compare y value_compare son sinónimos para el parámetro de plantilla rasgos. Ambos tipos se proporcionan en las clases hash_set y hash_multiset, donde son idénticos para la compatibilidad con las clases hash_map y hash_multimap, que son distintos.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_key_comp.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
  
   hash_set <int, hash_compare < int, less<int> > >hs1;  
   hash_set<int, hash_compare < int, less<int> > >::key_compare kc1  
          = hs1.key_comp( ) ;  
   bool result1 = kc1( 2, 3 ) ;  
   if( result1 == true )  
   {  
      cout << "kc1( 2,3 ) returns value of true, "  
           << "where kc1 is the function object of hs1."  
           << endl;  
   }  
   else  
   {  
      cout << "kc1( 2,3 ) returns value of false "  
           << "where kc1 is the function object of hs1."  
        << endl;  
   }  
  
   hash_set <int, hash_compare < int, greater<int> > > hs2;  
   hash_set<int, hash_compare < int, greater<int> > >::key_compare  
         kc2 = hs2.key_comp( ) ;  
   bool result2 = kc2( 2, 3 ) ;  
   if(result2 == true)  
   {  
      cout << "kc2( 2,3 ) returns value of true, "  
           << "where kc2 is the function object of hs2."  
           << endl;  
   }  
   else  
   {  
      cout << "kc2( 2,3 ) returns value of false, "  
           << "where kc2 is the function object of hs2."  
           << endl;  
   }  
}  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Un tipo que proporciona un objeto de función que puede comparar dos claves de ordenación para determinar el orden relativo de dos elementos en el hash_set.

typedef Traits key_compare;  

Comentarios

key_comparees un sinónimo del parámetro de plantilla Traits.

Para obtener más información sobre Traits ver el hash_set (clase) tema.

Tenga en cuenta que ambos key_compare y value_compare son sinónimos para el parámetro de plantilla rasgos. Ambos tipos se proporcionan para el conjunto y clases de conjunto múltiple, donde son idénticos para la compatibilidad con el mapa y clases multimap, donde son distintos.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

Vea el ejemplo de key_comp para obtener un ejemplo de cómo declarar y utilizar key_compare.

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Un tipo que describe un objeto almacenado como un elemento de hash_set en su capacidad como criterio de ordenación.

typedef Key key_type;  

Comentarios

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

Para obtener más información sobre Key, vea la sección Comentarios de la hash_set (clase) tema.

Tenga en cuenta que ambos key_type y value_type son sinónimos para el parámetro de plantilla clave. Ambos tipos se proporcionan en las clases hash_set y hash_multiset, donde son idénticos para la compatibilidad con las clases hash_map y hash_multimap, que son distintos.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

Vea el ejemplo de value_type para obtener un ejemplo de cómo declarar y utilizar key_type.

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve un iterador al primer elemento de hash_set con una clave que es igual o mayor que una clave especificada.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parámetros

key
Clave de argumento que se va a comparar con el criterio de ordenación de un elemento de la hash_set buscada.

Valor devuelto

Un iterador o const_iterator que direcciones de la ubicación de un elemento de hash_set que con una clave que es igual o mayor que la clave de argumento o que direcciona la ubicación del último elemento de la hash_set si no coinciden se encuentra la clave.

Comentarios

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_lower_bound.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;  
  
   hs1.insert( 10 );  
   hs1.insert( 20 );  
   hs1.insert( 30 );  
  
   hs1_RcIter = hs1.lower_bound( 20 );  
   cout << "The element of hash_set hs1 with a key of 20 is: "  
        << *hs1_RcIter << "." << endl;  
  
   hs1_RcIter = hs1.lower_bound( 40 );  
  
   // If no match is found for the key, end( ) is returned  
   if ( hs1_RcIter == hs1.end( ) )  
      cout << "The hash_set hs1 doesn't have an element "  
           << "with a key of 40." << endl;  
   else  
      cout << "The element of hash_set hs1 with a key of 40 is: "  
           << *hs1_RcIter << "." << endl;  
  
   // An element at a specific location in the hash_set can be found   
   // by using a dereferenced iterator that addresses the location  
   hs1_AcIter = hs1.end( );  
   hs1_AcIter--;  
   hs1_RcIter = hs1.lower_bound( *hs1_AcIter );  
   cout << "The element of hs1 with a key matching "  
        << "that of the last element is: "  
        << *hs1_RcIter << "." << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve la longitud máxima de la hash_set.

size_type max_size() const;

Valor devuelto

La longitud máxima permitida de la hash_set.

Comentarios

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_max_size.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
   hash_set <int>::size_type i;  
  
   i = hs1.max_size( );  
   cout << "The maximum possible length "  
        << "of the hash_set is " << i << "." << endl;  
}  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Reemplaza los elementos de la hash_set con una copia de otro hash_set.

hash_set& operator=(const hash_set& right);

hash_set& operator=(hash_set&& right);

Parámetros

ParámetroDescripción
rightEl hash_set se copian en el hash_set.

Comentarios

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

Ejemplo

// hash_set_operator_as.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set<int> v1, v2, v3;  
   hash_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;  
}  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Un tipo que proporciona un puntero a un elemento de hash_set.

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

Comentarios

Un tipo de puntero puede utilizarse para modificar el valor de un elemento.

En la mayoría de los casos, un iterador debe utilizarse para tener acceso a los elementos de un objeto hash_set.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve un iterador que direcciona el primer elemento de hash_set invertida.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor devuelto

Iterador bidireccional inverso dirige al primer elemento en hash_set invertida o direccionamiento lo que habría sido el último elemento de la hash_set irreversible.

Comentarios

rbeginse utiliza con hash_set invertida igual que comenzar se usa con hash_set.

Si el valor devuelto de rbegin se asigna a un const_reverse_iterator, entonces no se puede modificar el objeto hash_set. Si el valor devuelto de rbegin se asigna a un reverse_iterator, a continuación, el objeto hash_set puede modificarse.

rbeginpuede utilizarse para recorrer hash_set hacia atrás.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_rbegin.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
   hash_set <int>::iterator hs1_Iter;  
   hash_set <int>::reverse_iterator hs1_rIter;  
  
   hs1.insert( 10 );  
   hs1.insert( 20 );  
   hs1.insert( 30 );  
  
   hs1_rIter = hs1.rbegin( );  
   cout << "The first element in the reversed hash_set is "  
        << *hs1_rIter << "." << endl;  
  
   // begin can be used to start an iteration   
   // throught a hash_set in a forward order  
   cout << "The hash_set is: ";  
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( );  
         hs1_Iter++ )  
      cout << *hs1_Iter << " ";  
   cout << endl;  
  
   // rbegin can be used to start an iteration   
   // throught a hash_set in a reverse order  
   cout << "The reversed hash_set is: ";  
   for ( hs1_rIter = hs1.rbegin( ) ; hs1_rIter != hs1.rend( );  
         hs1_rIter++ )  
      cout << *hs1_rIter << " ";  
   cout << endl;  
  
   // A hash_set element can be erased by dereferencing to its key   
   hs1_rIter = hs1.rbegin( );  
   hs1.erase ( *hs1_rIter );  
  
   hs1_rIter = hs1.rbegin( );  
   cout << "After the erasure, the first element "  
        << "in the reversed hash_set is "<< *hs1_rIter << "."  
        << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Un tipo que proporciona una referencia a un elemento almacenado en hash_set.

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

Comentarios

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_reference.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
  
   hs1.insert( 10 );  
   hs1.insert( 20 );  
  
   // Declare and initialize a reference &Ref1 to the 1st element  
   int &Ref1 = *hs1.begin( );  
  
   cout << "The first element in the hash_set is "  
        << Ref1 << "." << endl;  
  
   // The value of the 1st element of the hash_set can be changed  
   // by operating on its (non-const) reference  
   Ref1 = Ref1 + 5;  
  
   cout << "The first element in the hash_set is now "  
        << *hs1.begin() << "." << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve un iterador que direcciona la ubicación del último elemento de hash_set invertida.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valor devuelto

Iterador bidireccional inverso que direcciona la ubicación del último elemento de hash_set invertida (la ubicación que había precedido al primer elemento de la hash_set sin invertir).

Comentarios

rendse utiliza con hash_set invertida igual que final se usa con hash_set.

Si el valor devuelto de rend se asigna a un const_reverse_iterator, entonces no se puede modificar el objeto hash_set. Si el valor devuelto de rend se asigna a un reverse_iterator, a continuación, el objeto hash_set puede modificarse. El valor devuelto por rend no se debe desreferenciar.

rendpuede utilizarse para probar si un iterador inverso llegó al final de su hash_set.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_rend.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
   hash_set <int>::iterator hs1_Iter;  
   hash_set <int>::reverse_iterator hs1_rIter;  
   hash_set <int>::const_reverse_iterator hs1_crIter;  
  
   hs1.insert( 10 );  
   hs1.insert( 20 );  
   hs1.insert( 30 );  
  
   hs1_rIter = hs1.rend( );  
   hs1_rIter--;  
   cout << "The last element in the reversed hash_set is "  
        << *hs1_rIter << "." << endl;  
  
   // end can be used to terminate an iteration   
   // throught a hash_set in a forward order  
   cout << "The hash_set is: ";  
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( );  
         hs1_Iter++ )  
      cout << *hs1_Iter << " ";  
   cout << "." << endl;  
  
   // rend can be used to terminate an iteration   
   // through a hash_set in a reverse order  
   cout << "The reversed hash_set is: ";  
   for ( hs1_rIter = hs1.rbegin( ) ; hs1_rIter != hs1.rend( );  
         hs1_rIter++ )  
      cout << *hs1_rIter << " ";  
   cout << "." << endl;  
  
   hs1_rIter = hs1.rend( );  
   hs1_rIter--;  
   hs1.erase ( *hs1_rIter );  
  
   hs1_rIter = hs1.rend( );  
   hs1_rIter--;  
   cout << "After the erasure, the last element in the "  
        << "reversed hash_set is " << *hs1_rIter << "."  
        << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Un tipo que proporciona un iterador bidireccional que puede leer o modificar un elemento de hash_set invertida.

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

Comentarios

Un tipo reverse_iterator se utiliza para recorrer en iteración el hash_set en orden inverso.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

Vea el ejemplo de rbegin para obtener un ejemplo de cómo declarar y utilizar reverse_iterator.

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve el número de elementos en el hash_set.

size_type size() const;

Valor devuelto

La longitud actual de la hash_set.

Comentarios

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_size.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
   hash_set <int> :: size_type i;  
  
   hs1.insert( 1 );  
   i = hs1.size( );  
   cout << "The hash_set length is " << i << "." << endl;  
  
   hs1.insert( 2 );  
   i = hs1.size( );  
   cout << "The hash_set length is now " << i << "." << endl;  
}  

The hash_set length is 1.  
The hash_set length is now 2.  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Un tipo de entero sin signo que puede representar el número de elementos de hash_set.

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

Comentarios

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

Vea el ejemplo de tamaño para obtener un ejemplo de cómo declarar y utilizarsize_type

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Intercambia los elementos de dos hash_sets.

void swap(hash_set& right);

Parámetros

right
Hash_set de argumento que proporciona los elementos que se deben intercambiar con el hash_set de destino.

Comentarios

La función miembro no invalida ninguna referencias, punteros o iteradores que designan los elementos de los dos hash_sets cuyos elementos se intercambian.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_swap.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1, hs2, hs3;  
   hash_set <int>::iterator hs1_Iter;  
  
   hs1.insert( 10 );  
   hs1.insert( 20 );  
   hs1.insert( 30 );  
   hs2.insert( 100 );  
   hs2.insert( 200 );  
   hs3.insert( 300 );  
  
   cout << "The original hash_set hs1 is:";  
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );  
         hs1_Iter++ )  
         cout << " " << *hs1_Iter;  
   cout   << "." << endl;  
  
   // This is the member function version of swap  
   hs1.swap( hs2 );  
  
   cout << "After swapping with hs2, list hs1 is:";  
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );  
         hs1_Iter++ )  
         cout << " " << *hs1_Iter;  
   cout  << "." << endl;  
  
   // This is the specialized template version of swap  
   swap( hs1, hs3 );  
  
   cout << "After swapping with hs3, list hs1 is:";  
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );  
         hs1_Iter++ )  
         cout << " " << *hs1_Iter;  
   cout   << "." << endl;  
}  

The original hash_set hs1 is: 10 20 30.  
After swapping with hs2, list hs1 is: 200 100.  
After swapping with hs3, list hs1 is: 300.  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Devuelve un iterador al primer elemento de hash_set que con una clave que es mayor que una clave especificada.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parámetros

key
Clave de argumento que se va a comparar con el criterio de ordenación de un elemento de la hash_set buscada.

Valor devuelto

Un iterador o const_iterator que direcciones de la ubicación de un elemento de hash_set que con una clave que es igual o mayor que la clave de argumento o que direcciona la ubicación del último elemento de la hash_set si no coinciden se encuentra la clave.

Comentarios

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_upper_bound.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;  
  
   hs1.insert( 10 );  
   hs1.insert( 20 );  
   hs1.insert( 30 );  
  
   hs1_RcIter = hs1.upper_bound( 20 );  
   cout << "The first element of hash_set hs1 with a key greater "  
        << "than 20 is: " << *hs1_RcIter << "." << endl;  
  
   hs1_RcIter = hs1.upper_bound( 30 );  
  
   // If no match is found for the key, end( ) is returned  
   if ( hs1_RcIter == hs1.end( ) )  
      cout << "The hash_set hs1 doesn't have an element "  
           << "with a key greater than 30." << endl;  
   else  
      cout << "The element of hash_set hs1 with a key > 40 is: "  
           << *hs1_RcIter << "." << endl;  
  
   // An element at a specific location in the hash_set can be found  
   // by using a dereferenced iterator addressing the location  
   hs1_AcIter = hs1.begin( );  
   hs1_RcIter = hs1.upper_bound( *hs1_AcIter );  
   cout << "The first element of hs1 with a key greater than "  
        << endl << "that of the initial element of hs1 is: "  
        << *hs1_RcIter << "." << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Recupera una copia del objeto de comparación utilizado para ordenar los valores de elemento de hash_set.

value_compare value_comp() const;

Valor devuelto

Devuelve el objeto de función hash_set se utiliza para ordenar sus elementos, que es el parámetro de plantilla Compare.

Para obtener más información sobre Compare, vea la sección Comentarios de la hash_set (clase) tema.

Comentarios

El objeto almacenado define la función miembro:

bool operator( const Key& _ xVal, const Key& _ yVal);

que devuelve true si _xVal precede y no es igual a _yVal en el criterio de ordenación.

Tenga en cuenta que ambos value_compare y key_compare son sinónimos para el parámetro de plantilla Compare. Ambos tipos se proporcionan en las clases hash_set y hash_multiset, donde son idénticos para la compatibilidad con las clases hash_map y hash_multimap, que son distintos.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

// hash_set_value_comp.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
  
   hash_set <int, hash_compare < int, less<int> > > hs1;  
   hash_set <int, hash_compare < int, less<int> >  >::value_compare  
      vc1 = hs1.value_comp( );  
   bool result1 = vc1( 2, 3 );  
   if( result1 == true )  
   {  
      cout << "vc1( 2,3 ) returns value of true, "  
           << "where vc1 is the function object of hs1."  
           << endl;  
   }  
   else  
   {  
      cout << "vc1( 2,3 ) returns value of false, "  
           << "where vc1 is the function object of hs1."  
           << endl;  
   }  
  
   hash_set <int, hash_compare < int, greater<int> > > hs2;  
   hash_set<int, hash_compare < int, greater<int> > >::value_compare  
      vc2 = hs2.value_comp( );  
   bool result2 = vc2( 2, 3 );  
   if( result2 == true )  
   {  
      cout << "vc2( 2,3 ) returns value of true, "  
           << "where vc2 is the function object of hs2."  
           << endl;  
   }  
   else  
   {  
      cout << "vc2( 2,3 ) returns value of false, "  
           << "where vc2 is the function object of hs2."  
           << endl;  
   }  
}  

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Un tipo que proporciona dos objetos de función, un predicado binario de clase compare que puede comparar dos valores de elemento de hash_set para determinar su orden relativo y un predicado unario que genera un valor hash de los elementos.

typedef key_compare value_compare;  

Comentarios

value_compare es un sinónimo del parámetro de plantilla Traits.

Para obtener más información sobre Traits ver el hash_set (clase) tema.

Tenga en cuenta que ambos key_compare y value_compare son sinónimos para el parámetro de plantilla rasgos. Ambos tipos se proporcionan en las clases hash_set y hash_multiset, donde son idénticos para la compatibilidad con las clases hash_map y hash_multimap, que son distintos.

En Visual C++ .NET 2003, los miembros de la <hash_map> y <hash_set> archivos de encabezado ya no están en el espacio de nombres std, pero en su lugar, se han movido al espacio de nombres stdext.</hash_set></hash_map> Consulte el espacio de nombres stdext para obtener más información.

Ejemplo

Vea el ejemplo de value_comp para obtener un ejemplo de cómo declarar y utilizar value_compare.

System_CAPS_ICON_note.jpg Nota

Esta API está obsoleta. La alternativa es unordered_set (clase).

Un tipo que describe un objeto almacenado como un elemento de hash_set en su capacidad como un valor.

typedef Key value_type;  

Ejemplo

// hash_set_value_type.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_set <int> hs1;  
   hash_set <int>::iterator hs1_Iter;  
  
   hash_set <int> :: value_type hsvt_Int;   // Declare value_type  
   hsvt_Int = 10;             // Initialize value_type  
  
   hash_set <int> :: key_type hskt_Int;   // Declare key_type  
   hskt_Int = 20;             // Initialize key_type  
  
   hs1.insert( hsvt_Int );         // Insert value into hs1  
   hs1.insert( hskt_Int );         // Insert key into hs1  
  
   // A hash_set accepts key_types or value_types as elements  
   cout << "The hash_set has elements:";  
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( ); hs1_Iter++)  
      cout << " " << *hs1_Iter;  
   cout << "." << endl;  
}  

The hash_set has elements: 10 20.  

Seguridad para subprocesos en la biblioteca estándar de C++
Biblioteca de plantillas estándar

Mostrar: