Se recomienda usar Visual Studio 2017

hash_multiset (Clase)

 

Publicado: junio de 2016

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

La clase de contenedor hash_multiset es una extensión de la biblioteca de plantillas estándar 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 actúan como valores clave y no es necesario que sean únicos.

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

Parámetros

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

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 acerca de la asignación y desasignación de memoria de hash_multiset. Este argumento es opcional y el valor predeterminado es asignador<>>.

El hash_multiset 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_multiset 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 principal ventaja de usar algoritmos hash en lugar de ordenar 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 el tiempo proporcional al logaritmo del número de elementos del contenedor 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).

La clase hash_multiset debe ser el contenedor asociativo preferido cuando la aplicación cumpla las condiciones que asocian los valores a sus claves. Los elementos de una clase hash_multiset pueden ser varios y actuar como sus propias claves de ordenación, por lo que las claves no son únicas. Un modelo para este tipo de estructura es una lista ordenada, por ejemplo, de palabras en las que las palabras pueden aparecer más de una vez. Si no se permitieran varias repeticiones de las palabras, la estructura de contenedor adecuada sería un hash_set. Si se asociaron definiciones únicas como valores a la lista de palabras clave únicas, la estructura adecuada para contener estos datos sería una clase hash_map. Si, por el contrario, las definiciones no son únicas, un hash_multimap sería el contenedor preferido.

El hash_multiset ordena la secuencia que controla llamando a un objeto de rasgos de hash almacenado 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 * <> * menos * <> </> > >.* Concretamente, para todos los valores de clave de tipo clave, la llamada rasgo( clave) 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 un hash_multiset 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 e 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 la clase hash_multiset es un iterador bidireccional, pero las funciones de miembro de clase inserción y hash_multiset 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 hash_multiset 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 hash_multiset 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_multisetConstruye un hash_multiset que está vacío o que es una copia de todo o de parte de otro hash_multiset.

Definiciones de tipo

allocator_typeTipo que representa la clase allocator para el objeto hash_multiset.
const_iteratorTipo que proporciona un iterador bidireccional que puede leer un elemento const en hash_multiset.
const_pointerTipo que proporciona un puntero a un elemento const en un hash_multiset.
const_referenceTipo que proporciona una referencia a un elemento const almacenado en un hash_multiset para leer y realizar operaciones const.
const_reverse_iteratorTipo que proporciona un iterador bidireccional que puede leer cualquier elemento const en hash_multiset.
difference_typeTipo entero con signo que proporciona la diferencia entre dos iteradores que direccionan elementos dentro del mismo hash_multiset.
iteradorTipo que proporciona un iterador bidireccional que puede leer o modificar cualquier elemento de hash_multiset.
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_multiset.
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_multiset.
referenciaTipo que proporciona una referencia a un elemento almacenado en un hash_multiset.
reverse_iteratorTipo que proporciona un iterador bidireccional que puede leer o modificar un elemento de hash_multiset invertido.
size_typeTipo entero sin signo que puede representar el número de elementos de un hash_multiset.
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_multiset 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_multiset en su capacidad como valor.

Funciones miembro

comenzarDevuelve un iterador que direcciona el primer elemento del hash_multiset.
hash_multiset::cbeginDevuelve un iterador constante que direcciona el primer elemento del hash_multiset.
hash_multiset::cendDevuelve un iterador constante que direcciona la ubicación que sigue al último elemento de hash_multiset.
BorrarBorra todos los elementos de un hash_multiset.
recuentoDevuelve el número de elementos de un hash_multiset cuya clave coincide con una clave especificada por un parámetro
hash_multiset::crbeginDevuelve un iterador constante que direcciona el primer elemento de hash_multiset invertido.
hash_multiset::crendDevuelve un iterador constante que direcciona la ubicación que sigue al último elemento de hash_multiset invertido.
hash_multiset::emplaceInserta en un hash_multiset un elemento construido en contexto.
hash_multiset::emplace_hintInserta en un hash_multiset un elemento construido en contexto, con una sugerencia de colocación.
vacíaComprueba si un hash_multiset está vacío.
finalDevuelve un iterador que direcciona la ubicación que sigue al último elemento de hash_multiset.
equal_rangeDevuelve un par de iteradores respectivamente al primer elemento de hash_multiset cuya clave mayor es que una clave especificada y al primer elemento del hash_multiset cuya clave es igual o mayor que la clave especificada.
BorrarQuita un elemento o un intervalo de elementos de una clase hash_multiset 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_multiset que tiene una clave equivalente a una clave especificada.
get_allocatorDevuelve una copia del objeto allocator utilizado para construir el hash_multiset.
InsertarInserta un elemento o un intervalo de elementos en un hash_multiset.
key_compRecupera una copia del objeto de comparación utilizado para ordenar claves de un hash_multiset.
lower_boundDevuelve un iterador al primer elemento de un hash_multiset cuya clave es igual o mayor que una clave especificada.
max_sizeDevuelve la longitud máxima del hash_multiset.
rbeginDevuelve un iterador que direcciona el primer elemento de hash_multiset invertido.
rendDevuelve un iterador que direcciona la ubicación que sigue al último elemento de hash_multiset invertido.
tamañoDevuelve el número de elementos de hash_multiset.
intercambioIntercambia los elementos de dos hash_multiset.
upper_boundDevuelve un iterador al primer elemento de hash_multiset 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_multiset.

Operadores

hash_multiset::operator =Reemplaza los elementos de la hash_multiset con una copia de otro hash_multiset.

Encabezado:<hash_set></hash_set>

Espacio de nombres: stdext

System_CAPS_ICON_note.jpg Nota

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

Tipo que representa la clase de asignador del objeto hash_multiset.

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

Ejemplo

Vea el ejemplo para get_allocator para obtener un ejemplo de usoallocator_type

System_CAPS_ICON_note.jpg Nota

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

Devuelve un iterador que direcciona el primer elemento en el hash_multiset.

const_iterator begin() const;

iterator begin();

Valor devuelto

Iterador bidireccional que direcciona el primer elemento en el hash_multiset o la ubicación que sigue un hash_multiset 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_multiset. Si el valor devuelto de comenzar se asigna a un iterador, se pueden modificar los elementos en el objeto hash_multiset.

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_multiset_begin.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hms1;  
   hash_multiset <int>::iterator hms1_Iter;  
   hash_multiset <int>::const_iterator hms1_cIter;  
  
   hms1.insert( 1 );  
   hms1.insert( 2 );  
   hms1.insert( 3 );  
  
   hms1_Iter = hms1.begin( );  
   cout << "The first element of hms1 is " << *hms1_Iter << endl;  
  
   hms1_Iter = hms1.begin( );  
   hms1.erase( hms1_Iter );  
  
   // The following 2 lines would err because the iterator is const  
   // hms1_cIter = hms1.begin( );  
   // hms1.erase( hms1_cIter );  
  
   hms1_cIter = hms1.begin( );  
   cout << "The first element of hms1 is now " << *hms1_cIter << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

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

Devuelve un iterador const que direcciona el primer elemento en el hash_multiset.

const_iterator cbegin() const;

Valor devuelto

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

Comentarios

Con el valor devuelto de cbegin, los elementos de la hash_multiset 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_multiset_cbegin.cpp  
// compile with: /EHsc  
#include <hash_multiset>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hs1;  
   hash_multiset <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_multiset (clase).

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

const_iterator cend() const;

Valor devuelto

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

Comentarios

cendse utiliza para probar si un iterador ha llegado al final de su hash_multiset. 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_multiset_cend.cpp  
// compile with: /EHsc  
#include <hash_multiset>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hs1;  
   hash_multiset <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_multiset (clase).

Borra todos los elementos de un hash_multiset.

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_multiset_clear.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hms1;  
  
   hms1.insert( 1 );  
   hms1.insert( 2 );  
  
   cout << "The size of the hash_multiset is initially " << hms1.size( )  
        << "." << endl;  
  
   hms1.clear( );  
   cout << "The size of the hash_multiset after clearing is "   
        << hms1.size( ) << "." << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

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

Un tipo que proporciona un iterador bidireccional que puede leer una const elemento en el hash_multiset.

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 de uso const_iterator.

System_CAPS_ICON_note.jpg Nota

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

Un tipo que proporciona un puntero a un const elemento en un hash_multiset.

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

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

Un tipo que proporciona una referencia a un const elemento almacenado en un hash_multiset 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_multiset_const_reference.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hms1;  
  
   hms1.insert( 10 );  
   hms1.insert( 20 );  
  
   // Declare and initialize a const_reference &Ref1   
   // to the 1st element  
   const int &Ref1 = *hms1.begin( );  
  
   cout << "The first element in the hash_multiset is "  
        << Ref1 << "." << endl;  
  
   // The following line would cause an error because the   
   // const_reference cannot be used to modify the hash_multiset  
   // Ref1 = Ref1 + 5;  
}  

The first element in the hash_multiset is 10.  

System_CAPS_ICON_note.jpg Nota

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

Un tipo que proporciona un iterador bidireccional que puede lee cualquier const elemento en el hash_multiset.

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_multiset 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 el const_reverse_iterator.

System_CAPS_ICON_note.jpg Nota

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

Devuelve el número de elementos de un objeto hash_multiset cuyo criterio coincide con un criterio especificado por un parámetro.

size_type count(const Key& key) const;

Parámetros

key
El criterio de los elementos cuya coincidencia debe buscarse a partir del objeto hash_multiset.

Valor devuelto

El número de elementos del objeto hash_multiset con el criterio especificado por un parámetro.

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

En el ejemplo siguiente se muestra el uso de la función miembro hash_multiset::count.

// hash_multiset_count.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
    using namespace std;  
    using namespace stdext;  
    hash_multiset<int> hms1;  
    hash_multiset<int>::size_type i;  
  
    hms1.insert(1);  
    hms1.insert(1);  
  
    // Keys do not need to be unique in hash_multiset,  
    // so duplicates may exist.  
    i = hms1.count(1);  
    cout << "The number of elements in hms1 with a sort key of 1 is: "  
         << i << "." << endl;  
  
    i = hms1.count(2);  
    cout << "The number of elements in hms1 with a sort key of 2 is: "  
         << i << "." << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

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

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

const_reverse_iterator crbegin() const;

Valor devuelto

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

Comentarios

crbeginse utiliza con invertido hash_multiset como hash_multiset:: BEGIN se usa con un hash_multiset.

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

crbeginpuede usarse para recorrer en iteración un hash_multiset 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_multiset_crbegin.cpp  
// compile with: /EHsc  
#include <hash_multiset>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hs1;  
   hash_multiset <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_multiset is "  
        << *hs1_crIter << "." << endl;  
}  

The first element in the reversed hash_multiset is 30.  

System_CAPS_ICON_note.jpg Nota

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

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

const_reverse_iterator crend() const;

Valor devuelto

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

Comentarios

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

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

crendpuede utilizarse para probar si un iterador inverso llegó al final de su hash_multiset.

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_multiset_crend.cpp  
// compile with: /EHsc  
#include <hash_multiset>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hs1;  
   hash_multiset <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_multiset is "  
        << *hs1_crIter << "." << endl;  
}  

The last element in the reversed hash_multiset is 10.  

System_CAPS_ICON_note.jpg Nota

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

Tipo de entero con signo que proporciona la diferencia entre dos iteradores que abordan los elementos dentro de la misma hash_multiset.

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 conjunto. Resta entre iteradores sólo 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_multiset_diff_type.cpp  
// compile with: /EHsc  
#include <iostream>  
#include <hash_set>  
#include <algorithm>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
  
   hash_multiset <int> hms1;  
   hash_multiset <int>::iterator hms1_Iter, hms1_bIter, hms1_eIter;  
  
   hms1.insert( 20 );  
   hms1.insert( 10 );  
  
   // hash_multiset elements need not be unique  
   hms1.insert( 20 );  
  
   hms1_bIter = hms1.begin( );  
   hms1_eIter = hms1.end( );  
  
   hash_multiset <int>::difference_type   df_typ5, df_typ10,  
        df_typ20;  
  
   df_typ5 = count( hms1_bIter, hms1_eIter, 5 );  
   df_typ10 = count( hms1_bIter, hms1_eIter, 10 );  
   df_typ20 = count( hms1_bIter, hms1_eIter, 20 );  
  
   // The keys & hence the elements of a hash_multiset  
   // need not be unique and may occur multiple times  
   cout << "The number '5' occurs " << df_typ5  
        << " times in hash_multiset hms1.\n";  
   cout << "The number '10' occurs " << df_typ10  
        << " times in hash_multiset hms1.\n";  
   cout << "The number '20' occurs " << df_typ20  
        << " times in hash_multiset hms1.\n";  
  
   // Count the number of elements in a hash_multiset  
   hash_multiset <int>::difference_type  df_count = 0;  
   hms1_Iter = hms1.begin( );  
   while ( hms1_Iter != hms1_eIter)  
   {  
      df_count++;  
      hms1_Iter++;  
   }  
  
   cout << "The number of elements in the hash_multiset hms1 is "   
        << df_count << "." << endl;  
}  

The number '5' occurs 0 times in hash_multiset hms1.  
The number '10' occurs 1 times in hash_multiset hms1.  
The number '20' occurs 2 times in hash_multiset hms1.  
The number of elements in the hash_multiset hms1 is 3.  

System_CAPS_ICON_note.jpg Nota

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

Inserta un elemento construido en contexto en un hash_multiset.

template <class ValTy>  
iterator insert(ValTy&& val);

Parámetros

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

Valor devuelto

El emplace función miembro devuelve un iterador que apunta a la posición donde se insertó el nuevo 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_multiset_emplace.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
#include <string>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset<string> hms3;  
   string str1("a");  
  
   hms3.emplace(move(str1));  
   cout << "After the emplace insertion, hms3 contains "  
      << *hms3.begin() << "." << endl;  
}  

After the emplace insertion, hms3 contains a.  

System_CAPS_ICON_note.jpg Nota

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

Inserta un elemento construido en contexto en un hash_multiset con una sugerencia de colocación.

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

Parámetros

ParámetroDescripción
valEl valor de un elemento que se va a insertar en el hash_multiset a menos que el hash_multiset 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_multiset::emplace función miembro devuelve un iterador que apunta a la posición donde se insertó el nuevo elemento en el hash_multiset.

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_multiset_emplace_hint.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
#include <string>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset<string> hms1;  
   string str1("a");  
  
   hms1.insert(hms1.begin(), move(str1));  
   cout << "After the emplace insertion, hms1 contains "  
      << *hms1.begin() << "." << endl;  
}  

After the emplace insertion, hms1 contains a.  

System_CAPS_ICON_note.jpg Nota

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

Comprueba si un hash_multiset está vacío.

bool empty() const;

Valor devuelto

True si el hash_multiset está vacía. false si el hash_multiset 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_multiset_empty.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hms1, hms2;  
   hms1.insert ( 1 );  
  
   if ( hms1.empty( ) )  
      cout << "The hash_multiset hms1 is empty." << endl;  
   else  
      cout << "The hash_multiset hms1 is not empty." << endl;  
  
   if ( hms2.empty( ) )  
      cout << "The hash_multiset hms2 is empty." << endl;  
   else  
      cout << "The hash_multiset hms2 is not empty." << endl;  
}  

The hash_multiset hms1 is not empty.  
The hash_multiset hms2 is empty.  

System_CAPS_ICON_note.jpg Nota

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

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

const_iterator end() const;

iterator end();

Valor devuelto

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

Comentarios

end se utiliza para probar si un iterador ha llegado al final de su hash_multiset. 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_multiset_end.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hms1;  
   hash_multiset <int> :: iterator hms1_Iter;  
   hash_multiset <int> :: const_iterator hms1_cIter;  
  
   hms1.insert( 1 );  
   hms1.insert( 2 );  
   hms1.insert( 3 );  
  
   hms1_Iter = hms1.end( );  
   hms1_Iter--;  
   cout << "The last element of hms1 is " << *hms1_Iter << endl;  
  
   hms1.erase( hms1_Iter );  
  
   // The following 3 lines would err because the iterator is const  
   // hms1_cIter = hms1.end( );  
   // hms1_cIter--;  
   // hms1.erase( hms1_cIter );  
  
   hms1_cIter = hms1.end( );  
   hms1_cIter--;  
   cout << "The last element of hms1 is now " << *hms1_cIter << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

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

Devuelve un par de iteradores respectivamente en el primer elemento de un hash_multiset con una clave que es mayor que una clave especificada y hasta el primer elemento en el hash_multiset con una clave que es igual o mayor que la clave.

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 desde el hash_multiset 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 a la primera iterador de un par pr devuelto por la función miembro, utilice pr. primera y 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. segundo y para desreferenciar el iterador de límite superior, use *( pr. en segundo lugar).

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

The upper bound of the element with a key of 20  
in the hash_multiset hms1 is: 30.  
The lower bound of the element with a key of 20  
in the hash_multiset hms1 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_multiset hms1 doesn't have an element with a key less than 40.  

System_CAPS_ICON_note.jpg Nota

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

Quita un elemento o un intervalo de elementos de un hash_multiset 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 va a quitar de hash_multiset.

first
Posición del primer elemento que se quitó de hash_multiset.

last
Posición inmediatamente siguiente al último elemento que se quitó de hash_multiset.

key
Clave del elemento que se va a quitar de hash_multiset.

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_multiset si no existe ese elemento. Para la tercera función miembro, número de elementos que se quitaron del hash_multiset.

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_multiset::erase.

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

After the 2nd element is deleted,  
 the hash_multiset hms1 is: 1 3 4.  
After the middle two elements are deleted,  
 the hash_multiset hms2 is: 16 4.  
After the element with a key of 2 is deleted,  
 the hash_multiset hms3 is: 0 1 3.  
The number of elements removed from hms3 is: 1.  
After another element with a key equal to that of the 2nd element  
 is deleted, the hash_multiset hms3 is: 0 3.  

System_CAPS_ICON_note.jpg Nota

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

Devuelve un iterador que direcciona la ubicación de un elemento en un hash_multiset 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 desde el hash_multiset 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 en el hash_multiset si se encuentra ninguna coincidencia para la clave.

Comentarios

La función miembro devuelve un iterador que direcciona un elemento en el hash_multiset cuyo criterio de ordenación es 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_multiset. Si el valor devuelto de buscar se asigna a un iterador, el objeto hash_multiset 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_multiset_find.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hms1;  
   hash_multiset <int> :: const_iterator hms1_AcIter, hms1_RcIter;  
  
   hms1.insert( 10 );  
   hms1.insert( 20 );  
   hms1.insert( 30 );  
  
   hms1_RcIter = hms1.find( 20 );  
   cout << "The element of hash_multiset hms1 with a key of 20 is: "  
        << *hms1_RcIter << "." << endl;  
  
   hms1_RcIter = hms1.find( 40 );  
  
   // If no match is found for the key, end( ) is returned  
   if ( hms1_RcIter == hms1.end( ) )  
      cout << "The hash_multiset hms1 doesn't have an element "  
           << "with a key of 40." << endl;  
   else  
      cout << "The element of hash_multiset hms1 with a key of 40 is: "  
           << *hms1_RcIter << "." << endl;  
  
   // The element at a specific location in the hash_multiset can be found   
   // by using a dereferenced iterator addressing the location  
   hms1_AcIter = hms1.end( );  
   hms1_AcIter--;  
   hms1_RcIter = hms1.find( *hms1_AcIter );  
   cout << "The element of hms1 with a key matching "  
        << "that of the last element is: "  
        << *hms1_RcIter << "." << endl;  
}  

The element of hash_multiset hms1 with a key of 20 is: 20.  
The hash_multiset hms1 doesn't have an element with a key of 40.  
The element of hms1 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_multiset (clase).

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

Allocator get_allocator() const;

Valor devuelto

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

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

Comentarios

Los asignadores de la clase hash_multiset 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_multiset_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_multiset <int, hash_compare <int, less<int> > > hms1;  
   hash_multiset <int, hash_compare <int, greater<int> > > hms2;  
   hash_multiset <double, hash_compare <double,  
      less<double> >, allocator<double> > hms3;  
  
   hash_multiset <int, hash_compare <int,  
      greater<int> > >::allocator_type hms2_Alloc;  
   hash_multiset <double>::allocator_type hms3_Alloc;  
   hms2_Alloc = hms2.get_allocator( );  
  
   cout << "The number of integers that can be allocated"  
        << endl << "before free memory is exhausted: "  
        << hms1.max_size( ) << "." << endl;  
  
   cout << "The number of doubles that can be allocated"  
        << endl << "before free memory is exhausted: "  
        << hms3.max_size( ) <<  "." << endl;  
  
   // The following lines create a hash_multiset hms4  
   // with the allocator of hash_multiset hms1.  
   hash_multiset <int>::allocator_type hms4_Alloc;  
   hash_multiset <int> hms4;  
   hms4_Alloc = hms2.get_allocator( );  
  
   // Two allocators are interchangeable if  
   // storage allocated from each can be  
   // deallocated by the other  
   if( hms2_Alloc == hms4_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_multiset (clase).

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

hash_multiset();

explicit hash_multiset(
    const Traits& Comp);

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

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

hash_multiset(
    hash_multiset&& Right  
};  
hash_multiset (initializer_list<Type> IList);

hash_multiset(
    initializer_list<Tu[e> IList, const Compare& Comp):  
hash_multiset(
    initializer_list<Type> IList, const Compare& Comp, const Allocator& Al);

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

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

template <class InputIterator>  
hash_multiset(
 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_multiset, que toma como valor predeterminado Allocator.
CompFunción de comparación de tipo const Traits que se utiliza para ordenar los elementos de hash_multiset, que toma como valor predeterminado hash_compare.
Righthash_multiset del que el hash_multiset 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.
IListinitializer_list que contiene los elementos que se van a copiar.

Comentarios

Todos los constructores almacenan un tipo de objeto de asignador que administra el almacenamiento de memoria para la hash_multiset y que puede devolver más adelante llamando a hash_multiset:: 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_multisets.

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_multiset y que puede devolver más adelante llamando a hash_multiset:: key_comp. Para obtener más información sobre Traits ver el hash_multiset (clase) tema.

Los tres primeros constructores especifican un inicial vacío hash_multiset, 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 especifica explícitamente el asignador de tipo ( Al) que se utilizará. La palabra clave explicit suprime ciertas clases de conversión automática de tipos.

El cuarto constructor mueve el hash_multiset``Right.

El quinto, el sexto y el séptimo constructores utilizan una initializer_list.

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

El orden real de los elementos de un contenedor de conjuntos al que se aplica el algoritmo hash 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_multiset (clase).

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

iterator insert(
    const Type& Val);

iterator insert(
    iterator Where,  
    const Type& Al);

void insert(
    initializer_list<Type> IList);

iterator insert(
    const Type& Val);

iterator insert(
    Iterator Where,   
    const Type& Val);

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

template <class ValTy>  
iterator insert(
    ValTy&& Val);

template <class ValTy>  
iterator insert(
    const_iterator Where,  
    ValTy&& Val);

Parámetros

ParámetroDescripción
ValValor de un elemento que se va a insertar en el hash_multiset a menos que el hash_multiset ya contenga ese elemento o, más en 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_multiset.
LastPosición situada más allá del último elemento que se va a copiar de un hash_multiset.
IListinitializer_list que contiene los elementos que se van a copiar.

Valor devuelto

Las dos primeras funciones miembro insert devuelven un iterador que apunta a la posición donde se insertó el nuevo elemento.

Las tres funciones miembro siguientes utilizan una initializer_list.

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

Comentarios

La inserción se puede realizar en tiempo constante amortizado para la versión de sugerencia de insert, en lugar de en tiempo logarítmico, si el punto de inserción sigue inmediatamente a Where.

System_CAPS_ICON_note.jpg Nota

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

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

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 para 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_multiset (clase).

Recupera una copia del objeto de comparación utilizado para ordenar claves en un hash_multiset.

key_compare key_comp() const;

Valor devuelto

Devuelve el parámetro de plantilla hash_multiset Traits, que contiene objetos de función que se usan para hash y para ordenar los elementos del contenedor.

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

Comentarios

El objeto almacenado define una 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 para que el hash_multiset y clases 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_multiset_key_comp.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
  
   hash_multiset <int, hash_compare < int, less<int> > >hms1;  
   hash_multiset<int, hash_compare < int, less<int> > >::key_compare kc1  
          = hms1.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 hms1."  
           << endl;  
   }  
   else  
   {  
      cout << "kc1( 2,3 ) returns value of false "  
           << "where kc1 is the function object of hms1."  
        << endl;  
   }  
  
   hash_multiset <int, hash_compare < int, greater<int> > > hms2;  
   hash_multiset<int, hash_compare < int, greater<int> > >::key_compare  
         kc2 = hms2.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 hms2."  
           << endl;  
   }  
   else  
   {  
      cout << "kc2( 2,3 ) returns value of false, "  
           << "where kc2 is the function object of hms2."  
           << endl;  
   }  
}  

System_CAPS_ICON_note.jpg Nota

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

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

typedef Traits key_compare;  

Comentarios

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

Para obtener más información sobre Traits ver el hash_multiset (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 para 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_multiset (clase).

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

typedef Key key_type;  

Comentarios

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

Tenga en cuenta que ambos key_type y value_type son sinónimos para el parámetro de plantilla clave. 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.

Para obtener más información sobre Key, vea la sección Comentarios de la hash_multiset (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 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_multiset (clase).

Devuelve un iterador al primer elemento en un hash_multiset 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 desde el hash_multiset buscada.

Valor devuelto

Un iterador o const_iterator que dirige a la ubicación del primer elemento en un hash_multiset con una clave que es igual o mayor que la clave de argumento o que direcciona la ubicación del último elemento en el hash_multiset si se encuentra ninguna coincidencia para 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_multiset_lower_bound.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main() {  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hms1;  
   hash_multiset <int> :: const_iterator hms1_AcIter, hms1_RcIter;  
  
   hms1.insert( 10 );  
   hms1.insert( 20 );  
   hms1.insert( 30 );  
  
   hms1_RcIter = hms1.lower_bound( 20 );  
   cout << "The element of hash_multiset hms1 with a key of 20 is: "  
        << *hms1_RcIter << "." << endl;  
  
   hms1_RcIter = hms1.lower_bound( 40 );  
  
   // If no match is found for the key, end( ) is returned  
   if ( hms1_RcIter == hms1.end( ) )  
      cout << "The hash_multiset hms1 doesn't have an element "  
           << "with a key of 40." << endl;  
   else  
      cout << "The element of hash_multiset hms1 with a key of 40 is: "  
           << *hms1_RcIter << "." << endl;  
  
   // An element at a specific location in the hash_multiset can be found   
   // by using a dereferenced iterator that addresses the location  
   hms1_AcIter = hms1.end( );  
   hms1_AcIter--;  
   hms1_RcIter = hms1.lower_bound( *hms1_AcIter );  
   cout << "The element of hms1 with a key matching "  
        << "that of the last element is: "  
        << *hms1_RcIter << "." << endl;  
}  

System_CAPS_ICON_note.jpg Nota

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

Devuelve la longitud máxima de la hash_multiset.

size_type max_size() const;

Valor devuelto

La longitud máxima permitida de la hash_multiset.

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_multiset_max_size.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hms1;  
   hash_multiset <int>::size_type i;  
  
   i = hms1.max_size( );     
   cout << "The maximum possible length "  
        << "of the hash_multiset is " << i << "." << endl;  
}  

System_CAPS_ICON_note.jpg Nota

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

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

hash_multiset& operator=(const hash_multiset& right);

hash_multiset& operator=(hash_multiset&& right);

Parámetros

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

Comentarios

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

Ejemplo

// hash_multiset_operator_as.cpp  
// compile with: /EHsc  
#include <hash_multiset>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset<int> v1, v2, v3;  
   hash_multiset<int>::iterator iter;  
  
   v1.insert(10);  
  
   cout << "v1 = " ;  
   for (iter = v1.begin(); iter != v1.end(); iter++)  
      cout << iter << " ";  
   cout << endl;  
  
   v2 = v1;  
   cout << "v2 = ";  
   for (iter = v2.begin(); iter != v2.end(); iter++)  
      cout << iter << " ";  
   cout << endl;  
  
// move v1 into v2  
   v2.clear();  
   v2 = move(v1);  
   cout << "v2 = ";  
   for (iter = v2.begin(); iter != v2.end(); iter++)  
      cout << iter << " ";  
   cout << endl;  
}  

System_CAPS_ICON_note.jpg Nota

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

Un tipo que proporciona un puntero a un elemento en un hash_multiset.

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 de conjunto múltiple.

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

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

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor devuelto

Iterador bidireccional inverso dirige al primer elemento en un hash_multiset invertida o direcciona lo que habría sido el último elemento en el hash_multiset irreversible.

Comentarios

rbeginse utiliza con un hash_multiset invertida igual que comenzar se usa con un hash_multiset.

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

rbeginpuede utilizarse para iterar a través de un hash_multiset 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_multiset_rbegin.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hms1;  
   hash_multiset <int>::iterator hms1_Iter;  
   hash_multiset <int>::reverse_iterator hms1_rIter;  
  
   hms1.insert( 10 );  
   hms1.insert( 20 );  
   hms1.insert( 30 );  
  
   hms1_rIter = hms1.rbegin( );  
   cout << "The first element in the reversed hash_multiset is "  
        << *hms1_rIter << "." << endl;  
  
   // begin can be used to start an iteration   
   // throught a hash_multiset in a forward order  
   cout << "The hash_multiset is: ";  
   for ( hms1_Iter = hms1.begin( ) ; hms1_Iter != hms1.end( );  
         hms1_Iter++ )  
      cout << *hms1_Iter << " ";  
   cout << endl;  
  
   // rbegin can be used to start an iteration   
   // throught a hash_multiset in a reverse order  
   cout << "The reversed hash_multiset is: ";  
   for ( hms1_rIter = hms1.rbegin( ) ; hms1_rIter != hms1.rend( );  
         hms1_rIter++ )  
      cout << *hms1_rIter << " ";  
   cout << endl;  
  
   // A hash_multiset element can be erased by dereferencing to its key   
   hms1_rIter = hms1.rbegin( );  
   hms1.erase ( *hms1_rIter );  
  
   hms1_rIter = hms1.rbegin( );  
   cout << "After the erasure, the first element "  
        << "in the reversed hash_multiset is "<< *hms1_rIter << "."  
        << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

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

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

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

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

System_CAPS_ICON_note.jpg Nota

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

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

const_reverse_iterator rend() const;

reverse_iterator rend();

Valor devuelto

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

Comentarios

rendse utiliza con un hash_multiset invertida igual que final se usa con un hash_multiset.

Si el valor devuelto de rend se asigna a un const_reverse_iterator, entonces no se puede modificar el objeto hash_multiset. Si el valor devuelto de rend se asigna a un reverse_iterator, a continuación, el objeto hash_multiset 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_multiset.

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

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

System_CAPS_ICON_note.jpg Nota

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

Un tipo que proporciona un iterador bidireccional que puede leer o modificar un elemento de un hash_multiset 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_multiset 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 para 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_multiset (clase).

Devuelve el número de elementos en el hash_multiset.

size_type size() const;

Valor devuelto

La longitud actual de la hash_multiset.

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_multiset_size.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hms1;  
   hash_multiset <int> :: size_type i;  
  
   hms1.insert( 1 );  
   i = hms1.size( );  
   cout << "The hash_multiset length is " << i << "." << endl;  
  
   hms1.insert( 2 );  
   i = hms1.size( );  
   cout << "The hash_multiset length is now " << i << "." << endl;  
}  

The hash_multiset length is 1.  
The hash_multiset length is now 2.  

System_CAPS_ICON_note.jpg Nota

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

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

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 para 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_multiset (clase).

Intercambia los elementos de dos hash_multisets.

void swap(hash_multiset& right);

Parámetros

right
Hash_multiset de argumento que proporciona los elementos que se deben intercambiar con el hash_multiset de destino.

Comentarios

La función miembro no invalida ninguna referencias, punteros o iteradores que designan los elementos de los dos hash_multisets 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_multiset_swap.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hms1, hms2, hms3;  
   hash_multiset <int>::iterator hms1_Iter;  
  
   hms1.insert( 10 );  
   hms1.insert( 20 );  
   hms1.insert( 30 );  
   hms2.insert( 100 );  
   hms2.insert( 200 );  
   hms3.insert( 300 );  
  
   cout << "The original hash_multiset hms1 is:";  
   for ( hms1_Iter = hms1.begin( ); hms1_Iter != hms1.end( );  
         hms1_Iter++ )  
         cout << " " << *hms1_Iter;  
   cout   << "." << endl;  
  
   // This is the member function version of swap  
   hms1.swap( hms2 );  
  
   cout << "After swapping with hms2, list hms1 is:";  
   for ( hms1_Iter = hms1.begin( ); hms1_Iter != hms1.end( );  
         hms1_Iter++ )  
         cout << " " << *hms1_Iter;  
   cout  << "." << endl;  
  
   // This is the specialized template version of swap  
   swap( hms1, hms3 );  
  
   cout << "After swapping with hms3, list hms1 is:";  
   for ( hms1_Iter = hms1.begin( ); hms1_Iter != hms1.end( );  
         hms1_Iter++ )  
         cout << " " << *hms1_Iter;  
   cout   << "." << endl;  
}  

The original hash_multiset hms1 is: 10 20 30.  
After swapping with hms2, list hms1 is: 200 100.  
After swapping with hms3, list hms1 is: 300.  

System_CAPS_ICON_note.jpg Nota

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

Devuelve un iterador al primer elemento en un hash_multiset 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 desde el hash_multiset buscada.

Valor devuelto

Un iterador o const_iterator que dirige a la ubicación del primer elemento en un hash_multiset con una clave mayor que la clave de argumento o que direcciona la ubicación del último elemento en el hash_multiset si se encuentra ninguna coincidencia para 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_multiset_upper_bound.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
   hash_multiset <int> hms1;  
   hash_multiset <int> :: const_iterator hms1_AcIter, hms1_RcIter;  
  
   hms1.insert( 10 );  
   hms1.insert( 20 );  
   hms1.insert( 30 );  
  
   hms1_RcIter = hms1.upper_bound( 20 );  
   cout << "The first element of hash_multiset hms1" << endl  
        << " with a key greater than 20 is: "  
        << *hms1_RcIter << "." << endl;  
  
   hms1_RcIter = hms1.upper_bound( 30 );  
  
   // If no match is found for the key, end( ) is returned  
   if ( hms1_RcIter == hms1.end( ) )  
      cout << "The hash_multiset hms1 doesn't have an element "  
           << "\n with a key greater than 30." << endl;  
   else  
      cout << "The element of hash_multiset hms1"  
           << "with a key > 40 is: "  
           << *hms1_RcIter << "." << endl;  
  
   // An element at a specific location in the hash_multiset can be  
   // found by using a dereferenced iterator addressing the location  
   hms1_AcIter = hms1.begin( );  
   hms1_RcIter = hms1.upper_bound( *hms1_AcIter );  
   cout << "The first element of hms1\n with a key greater than "  
        << endl << "that of the initial element of hms1 is: "  
        << *hms1_RcIter << "." << endl;  
}  

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

System_CAPS_ICON_note.jpg Nota

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

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

value_compare value_comp() const;

Valor devuelto

Devuelve el parámetro de plantilla hash_multiset Traits, que contiene objetos de función que se utilizan con hash y elementos de pedido del contenedor.

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

Comentarios

El objeto almacenado define una función miembro:

bool operator( constKey&_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 para que el hash_multiset y clases 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_multiset_value_comp.cpp  
// compile with: /EHsc  
#include <hash_set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   using namespace stdext;  
  
   hash_multiset <int, hash_compare < int, less<int> > > hms1;  
   hash_multiset <int, hash_compare < int, less<int> > >::value_compare  
      vc1 = hms1.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 hms1."  
           << endl;  
   }  
   else  
   {  
      cout << "vc1( 2,3 ) returns value of false, "  
           << "where vc1 is the function object of hms1."  
           << endl;  
   }  
  
   hash_multiset <int, hash_compare < int, greater<int> > > hms2;  
   hash_multiset<int, hash_compare < int, greater<int> > >::  
           value_compare vc2 = hms2.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 hms2."  
           << endl;  
   }  
   else  
   {  
      cout << "vc2( 2,3 ) returns value of false, "  
           << "where vc2 is the function object of hms2."  
           << endl;  
   }  
}  

vc1( 2,3 ) returns value of true, where vc1 is the function object of hms1.  
vc2( 2,3 ) returns value of false, where vc2 is the function object of hms2.  

System_CAPS_ICON_note.jpg Nota

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

Un tipo que proporciona dos objetos de función, un predicado binario de clase compare que puede comparar dos valores de elemento de un hash_multiset 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_multiset (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 de clases y multiset, que son idénticos, para compatibilidad con las clases map y 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 para 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_multiset (clase).

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

typedef Key value_type;  

Ejemplo

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

The hash_multiset has elements: 10 20.  

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

Mostrar: