Clase hash_map

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Almacena y recupera datos rápidamente de una colección en la que cada elemento es un par que tiene una clave de ordenación cuyo valor es único y un valor de datos asociado.

Sintaxis

template <class Key,
    class Type,
    class Traits=hash_compare<Key, less<Key>>,
    class Allocator=allocator<pair <const Key, Type>>>
class hash_map

Parámetros

Key
Tipo de datos de clave que se almacenará en hash_map.

Type
Tipo de datos de elementos que se va a almacenar en la hash_map.

Traits
Tipo que incluye dos objetos de función: uno de clase compare que 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 hash_compare<Key, less<Key>> es el valor predeterminado.

Allocator
Tipo que representa el objeto asignador almacenado que encapsula los detalles acerca de la asignación y desasignación de memoria de hash_map. Este argumento es opcional y el valor predeterminado es allocator<pair <const Key, Type>>.

Comentarios

El hash_map 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.

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

• Un contenedor asociativo de pares, ya que los valores de datos de sus elementos son distintos de sus valores de clave.

• Una plantilla de clase, 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 hash_map se puede cambiar directamente, pero no su valor de clave asociado. En su lugar, se deben eliminar los valores de clave asociados a los antiguos elementos e insertar los nuevos valores de clave asociados a los elementos nuevos.

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 elemento hash_map debe ser el contenedor asociativo elegido cuando la aplicación satisface las condiciones que asocian los valores a sus claves. Un modelo de este tipo de estructura es una lista ordenada de palabras clave únicas con valores de cadena asociados que proporcionan, por ejemplo, definiciones. Si por el contrario las palabras tienen más una definición correcta, de modo que las claves no son únicas, el contenedor más adecuado sería hash_multimap. Por otra parte, si solo se almacenara la lista de palabras, el contenedor correcto sería hash_set. Si se permitieran varias repeticiones de las palabras, la estructura de contenedor adecuada sería hash_multiset.

hash_map ordena la secuencia que controla al llamar a un objeto hash Traits almacenado de la clase value_compare. Se puede obtener acceso a este objeto almacenado mediante una llamada 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, less<Key>>. En concreto, para todos los valores Key de tipo Key, la llamada a Traits( Key) produce una distribución de valores de tipo size_t. Para obtener más información, vea hash_compare.

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 e y, y un valor devuelto de true o false. Una ordenación impuesta en un hash_map 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) como 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 no se puede predecir en general 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_map es un iterador bidireccional, pero las funciones miembro de la clase insert y hash_map 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.

Constructores

Constructor	Descripción
hash_map	Construye un hash_map que está vacío o que es una copia de todo o de parte de otro hash_map.

Typedefs

Nombre de tipo	Descripción
allocator_type	Tipo que representa la clase allocator para el objeto hash_map.
const_iterator	Tipo que proporciona un iterador bidireccional que puede leer un elemento const en hash_map.
const_pointer	Tipo que proporciona un puntero a un elemento const en un hash_map.
const_reference	Tipo que proporciona una referencia a un elemento const almacenado en un hash_map para leer y realizar operaciones const.
const_reverse_iterator	Tipo que proporciona un iterador bidireccional que puede leer cualquier elemento const en hash_map.
difference_type	Tipo entero con signo que se puede usar para representar el número de elementos de un hash_map en un intervalo entre elementos a los que apuntan los iteradores.
iterator	Tipo que proporciona un iterador bidireccional que puede leer o modificar cualquier elemento de hash_map.
key_compare	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_map.
key_type	Tipo que describe el objeto de clave de ordenación que constituye cada elemento de hash_map.
mapped_type	Tipo que representa el tipo de datos almacenados en un hash_map.
pointer	Tipo que proporciona un puntero a un elemento de hash_map.
reference	Tipo que proporciona una referencia a un elemento almacenado en un hash_map.
reverse_iterator	Tipo que proporciona un iterador bidireccional que puede leer o modificar un elemento de hash_map invertido.
size_type	Tipo entero sin signo que puede representar el número de elementos de un hash_map.
value_type	Tipo que proporciona un objeto de función que puede comparar dos elementos como claves de ordenación para determinar su orden relativo en el hash_map.

Funciones miembro

Función de miembro	Descripción
at	Busca un elemento en un hash_map con un valor de clave especificado.
begin	Devuelve un iterador que direcciona el primer elemento del hash_map.
cbegin	Devuelve un iterador constante que direcciona el primer elemento del hash_map.
cend	Devuelve un iterador constante que direcciona la ubicación que sigue al último elemento de hash_map.
clear	Borra todos los elementos de un hash_map.
count	Devuelve el número de elementos de un hash_map cuya clave coincide con una clave especificada por un parámetro.
crbegin	Devuelve un iterador const que direcciona el primer elemento de un hash_map invertido.
crend	Devuelve un iterador const que direcciona la ubicación que sigue al último elemento de un hash_map invertido.
emplace	Inserta en un hash_map un elemento construido en contexto.
emplace_hint	Inserta en un hash_map un elemento construido en contexto, con una sugerencia de colocación.
empty	Comprueba si un hash_map está vacío.
end	Devuelve un iterador que direcciona la ubicación que sigue al último elemento de hash_map.
equal_range	Devuelve un par de iteradores, respectivamente, al primer elemento de hash_map cuya clave mayor es que una clave especificada y al primer elemento del hash_map cuya clave es igual o mayor que la clave especificada.
erase	Quita un elemento o un intervalo de elementos de un hash_map de las posiciones especificadas.
find	Devuelve un iterador que direcciona la ubicación de un elemento en un hash_map que tiene una clave equivalente a una clave especificada.
get_allocator	Devuelve una copia del objeto allocator utilizado para construir el hash_map.
insert	Inserta un elemento o un intervalo de elementos en un hash_map.
key_comp	Devuelve un iterador al primer elemento de hash_map cuyo valor de clave es igual o mayor que el de una clave especificada.
lower_bound	Devuelve un iterador al primer elemento de hash_map cuyo valor de clave es igual o mayor que el de una clave especificada.
max_size	Devuelve la longitud máxima del hash_map.
rbegin	Devuelve un iterador que direcciona el primer elemento de hash_map invertido.
rend	Devuelve un iterador que direcciona la ubicación que sigue al último elemento de hash_map invertido.
size	Devuelve el número de elementos de hash_map.
swap	Intercambia los elementos de dos hash_map.
upper_bound	Devuelve un iterador al primer elemento de hash_map cuyo valor de clave es mayor que el de una clave especificada.
value_comp	Recupera una copia del objeto de comparación utilizado para ordenar valores de elemento de hash_map.

Operadores

Operador	Descripción
operator[]	Inserta un elemento en un hash_map con un valor de clave especificado.
hash_map::operator=	Reemplaza los elementos de un hash_map con una copia de otro hash_map.

Requisitos

Encabezado: <hash_map>

Espacio de nombres: stdext

hash_map::allocator_type

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo que representa la clase de asignador para el objeto hash_map.

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

Ejemplo

Vea el ejemplo de get_allocator para obtener un ejemplo donde se usa allocator_type.

hash_map::at

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Busca un elemento en un hash_map con un valor de clave especificado.

Type& at(const Key& key);

const Type& at(const Key& key) const;

Parámetros

key
El valor de clave del elemento que se tiene que encontrar.

Valor devuelto

Una referencia al valor de datos del elemento encontrado.

Comentarios

Si no se encuentra el valor de clave de argumento, la función genera un objeto de la clase out_of_range.

Ejemplo

// hash_map_at.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;

   // Insert data values
   hm1.insert ( cInt2Int ( 1, 10 ) );
   hm1.insert ( cInt2Int ( 2, 20 ) );
   hm1.insert ( cInt2Int ( 3, 30 ) );

   cout  << "The values of the mapped elements are:";
   for ( int i = 1 ; i <= hm1.size() ; i++ )
      cout << " " << hm1.at(i);
   cout << "." << endl;
}

hash_map::begin

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve un iterador que direcciona el primer elemento del hash_map.

const_iterator begin() const;

iterator begin();

Valor devuelto

Iterador bidireccional que direcciona el primer elemento de hash_map o a la ubicación siguiente a un hash_map vacío.

Ejemplo

// hash_map_begin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 0, 0 ) );
   hm1.insert ( Int_Pair ( 1, 1 ) );
   hm1.insert ( Int_Pair ( 2, 4 ) );

   hm1_cIter = hm1.begin ( );
   cout << "The first element of hm1 is "
        << hm1_cIter -> first << "." << endl;

   hm1_Iter = hm1.begin ( );
   hm1.erase ( hm1_Iter );

   // The following 2 lines would err because the iterator is const
   // hm1_cIter = hm1.begin ( );
   // hm1.erase ( hm1_cIter );

   hm1_cIter = hm1.begin( );
   cout << "The first element of hm1 is now "
        << hm1_cIter -> first << "." << endl;
}

The first element of hm1 is 0.
The first element of hm1 is now 1.

hash_map::cbegin

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve un iterador constante que direcciona el primer elemento del hash_map.

const_iterator cbegin() const;

Valor devuelto

Iterador bidireccional const que direcciona el primer elemento de hash_map o a la ubicación siguiente a un hash_map vacío.

Ejemplo

// hash_map_cbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 2, 4 ) );

   hm1_cIter = hm1.cbegin ( );
   cout << "The first element of hm1 is "
        << hm1_cIter -> first << "." << endl;
   }

The first element of hm1 is 2.

hash_map::cend

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve un iterador constante que direcciona la ubicación que sigue al último elemento de hash_map.

const_iterator cend() const;

Valor devuelto

Iterador bidireccional const que dirige a la ubicación que sigue al último elemento de un hash_map. Si el hash_map está vacío, hash_map::cend == hash_map::begin.

Comentarios

cend se usa para comprobar si un iterador ha llegado al final de su hash_map.

El valor devuelto por cend no se debe desreferenciar.

Ejemplo

// hash_map_cend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_cIter = hm1.cend( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is "
        << hm1_cIter -> second << "." << endl;
   }

The value of last element of hm1 is 30.

hash_map::clear

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Borra todos los elementos de un hash_map.

void clear();

Comentarios

Ejemplo

En el ejemplo siguiente se muestra el uso de la función miembro hash_map::clear.

// hash_map_clear.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 1));
    hm1.insert(Int_Pair(2, 4));

    i = hm1.size();
    cout << "The size of the hash_map is initially "
         << i << "." << endl;

    hm1.clear();
    i = hm1.size();
    cout << "The size of the hash_map after clearing is "
         << i << "." << endl;
}

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

hash_map::const_iterator

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo que proporciona un iterador bidireccional que puede leer un elemento const en hash_map.

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.

El elemento const_iterator definido mediante hash_map apunta a elementos que son value_type, esto es, que son de tipo pair< const Key, Type >, cuyo primer miembro es la clave del elemento y el segundo, la referencia asignada que el elemento conserva.

Para desreferenciar un const_iterator cIter que apunta a un elemento de , hash_mapuse el -> operador .

Para tener acceso al valor de clave del elemento, use cIter->first, que equivale a (*cIter).first. Para tener acceso al valor de la referencia asignada del elemento, use cIter->second, que equivale a (*cIter).second.

Ejemplo

Vea el ejemplo de begin para obtener un ejemplo donde se usa const_iterator.

hash_map::const_pointer

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo que proporciona un puntero a un elemento const en un hash_map.

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, se debe usar iterator para obtener acceso a los elementos de un objeto hash_map.

hash_map::const_reference

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo que proporciona una referencia a un elemento const almacenado en un hash_map para leer y realizar operaciones const.

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

Comentarios

Ejemplo

// hash_map_const_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map<int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( hm1.begin( ) -> first );

   // The following line would cause an error because the
   // non-const_reference cannot be used to access the key
   // int &Ref1 = ( hm1.begin( ) -> first );

   cout << "The key of the first element in the hash_map is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( hm1.begin( ) -> second );

   cout << "The data value of the first element in the hash_map is "
        << Ref2 << "." << endl;
}

The key of the first element in the hash_map is 1.
The data value of the first element in the hash_map is 10.

hash_map::const_reverse_iterator

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo que proporciona un iterador bidireccional que puede leer cualquier elemento const en hash_map.

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

Comentarios

Un tipo const_reverse_iterator no puede modificar el valor de un elemento y se usa para iterar por hash_map en orden inverso.

El elemento const_reverse_iterator definido mediante hash_map apunta a elementos que son value_type, esto es, que son de tipo pair< const Key, Type >, cuyo primer miembro es la clave del elemento y el segundo, la referencia asignada que el elemento conserva.

Para desreferenciar un const_reverse_iterator crIter que apunta a un elemento de , hash_mapuse el -> operador .

Para tener acceso al valor de clave del elemento, use crIter->first, que equivale a (*crIter).first. Para tener acceso al valor de la referencia asignada del elemento, use crIter->second, que equivale a (*crIter).first.

Ejemplo

Vea el ejemplo de rend para obtener un ejemplo de cómo declarar y usar const_reverse_iterator.

hash_map::count

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

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

size_type count(const Key& key) const;

Parámetros

key
Valor de clave de los elementos cuya coincidencia debe buscarse a partir del objeto hash_map.

Valor devuelto

1 si hash_map contiene un elemento cuyo criterio de ordenación coincide con el criterio del parámetro; 0 si hash_map no contiene ningún elemento con el mismo criterio.

Comentarios

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

lower_bound(key), upper_bound(key)

que es 0 o 1 en el caso de hash_map, que es un contenedor asociativo único.

Ejemplo

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

// hash_map_count.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair (1, 1));
    hm1.insert(Int_Pair (2, 1));
    hm1.insert(Int_Pair (1, 4));
    hm1.insert(Int_Pair (2, 1));

    // Keys must be unique in hash_map, so duplicates are ignored
    i = hm1.count(1);
    cout << "The number of elements in hm1 with a sort key of 1 is: "
         << i << "." << endl;

    i = hm1.count(2);
    cout << "The number of elements in hm1 with a sort key of 2 is: "
         << i << "." << endl;

    i = hm1.count(3);
    cout << "The number of elements in hm1 with a sort key of 3 is: "
         << i << "." << endl;
}

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

hash_map::crbegin

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve un iterador const que direcciona el primer elemento de un hash_map invertido.

const_reverse_iterator crbegin() const;

Valor devuelto

Iterador bidireccional inverso const que dirige al primer elemento de un objeto hash_map invertido (o que dirige a lo que fue el último elemento de hash_map sin invertir).

Comentarios

crbegin se usa con un hash_map invertido igual que begin se usa con un hash_map.

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

crbegin puede usarse para iterar un objeto hash_map hacia atrás.

Ejemplo

// hash_map_crbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_crIter = hm1.crbegin( );
   cout << "The first element of the reversed hash_map hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The first element of the reversed hash_map hm1 is 3.

hash_map::crend

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve un iterador const que direcciona la ubicación que sigue al último elemento de un hash_map invertido.

const_reverse_iterator crend() const;

Valor devuelto

Iterador bidireccional inverso const que dirige a la ubicación siguiente al último elemento de un hash_map invertido (la ubicación que había precedido al primer elemento de hash_map sin invertir).

Comentarios

crend se usa con un hash_map invertido igual que hash_map::end se usa con un hash_map.

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

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

El valor devuelto por crend no se debe desreferenciar.

Ejemplo

// hash_map_crend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_crIter = hm1.crend( );
   hm1_crIter--;
   cout << "The last element of the reversed hash_map hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The last element of the reversed hash_map hm1 is 3.

hash_map::difference_type

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo entero con signo que se puede usar para representar el número de elementos de un hash_map en un intervalo entre elementos a los que apuntan los iteradores.

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

Ejemplo

// hash_map_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_map>
#include <algorithm>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 3, 20 ) );

   // The following won't insert, because map keys are unique
   hm1.insert ( Int_Pair ( 2, 30 ) );

   hash_map <int, int>::iterator hm1_Iter, hm1_bIter, hm1_eIter;
   hm1_bIter = hm1.begin( );
   hm1_eIter = hm1.end( );

   // Count the number of elements in a hash_map
   hash_map <int, int>::difference_type  df_count = 0;
   hm1_Iter = hm1.begin( );
   while ( hm1_Iter != hm1_eIter)
   {
      df_count++;
      hm1_Iter++;
   }

   cout << "The number of elements in the hash_map hm1 is: "
        << df_count << "." << endl;

   cout  << "The keys of the mapped elements are:";
   for ( hm1_Iter= hm1.begin( ) ; hm1_Iter!= hm1.end( ) ;
         hm1_Iter++)
      cout << " " << hm1_Iter-> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( hm1_Iter= hm1.begin( ) ; hm1_Iter!= hm1.end( ) ;
         hm1_Iter++)
      cout << " " << hm1_Iter-> second;
   cout << "." << endl;
}

The number of elements in the hash_map hm1 is: 3.
The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 20.

hash_map::emplace

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Inserta en un hash_map un elemento construido en contexto.

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

Parámetros

val
Valor usado para construir con movimiento un elemento que se va a insertar en el objeto hash_map, a menos que hash_map ya contenga ese elemento (o, de manera más general, un elemento cuya clave esté ordenada de manera equivalente).

Valor devuelto

La función miembro emplace devuelve un par cuyo componente bool devuelve true si se hizo una inserción y false si el objeto hash_map ya contenía un elemento cuya clave tenía un valor equivalente en la ordenación y cuyo componente iterator devuelve la dirección donde se insertó un nuevo elemento o donde ya estaba el elemento.

Para tener acceso al componente iterator 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).

Comentarios

El hash_map::value_type de un elemento es un par, de modo que el valor de un elemento será un par ordenado en el que el primer componente es igual que el valor de clave y el segundo componente es igual que el valor de datos del elemento.

Ejemplo

// hash_map_emplace.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(move(is1));
    cout << "After the emplace insertion, hm1 contains:" << endl
      << " " << hm1.begin()->first
      << " => " << hm1.begin()->second
      << endl;
}

After the emplace insertion, hm1 contains:
1 => a

hash_map::emplace_hint

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

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

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

Parámetros

val
Valor usado para construir con movimiento un elemento que se va a insertar en el objeto hash_map, a menos que hash_map ya contenga ese elemento (o, de manera más general, un elemento cuya clave esté ordenada de manera equivalente).

c
Sugerencia con respecto al lugar donde se va a empezar a buscar el punto correcto de inserción.

Valor devuelto

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

Comentarios

El hash_map::value_type de un elemento es un par, de modo que el valor de un elemento será un par ordenado en el que el primer componente es igual que el valor de clave y el segundo componente es igual que el valor de datos del elemento.

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.

Ejemplo

// hash_map_emplace_hint.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(hm1.begin(), move(is1));
    cout << "After the emplace, hm1 contains:" << endl
      << " " << hm1.begin()->first
      << " => " << hm1.begin()->second
      << endl;
}

After the emplace insertion, hm1 contains:
1 => a

hash_map::empty

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Comprueba si un hash_map está vacío.

bool empty() const;

Valor devuelto

true si hash_map está vacío; false si hash_map no está vacío.

Comentarios

Ejemplo

// hash_map_empty.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1, hm2;

   typedef pair <int, int> Int_Pair;
   hm1.insert ( Int_Pair ( 1, 1 ) );

   if ( hm1.empty( ) )
      cout << "The hash_map hm1 is empty." << endl;
   else
      cout << "The hash_map hm1 is not empty." << endl;

   if ( hm2.empty( ) )
      cout << "The hash_map hm2 is empty." << endl;
   else
      cout << "The hash_map hm2 is not empty." << endl;
}

The hash_map hm1 is not empty.
The hash_map hm2 is empty.

hash_map::end

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve un iterador que direcciona la ubicación que sigue al último elemento de hash_map.

const_iterator end() const;

iterator end();

Valor devuelto

Iterador bidireccional que dirige a la ubicación que sigue al último elemento de un objeto hash_map. Si el hash_map está vacío, hash_map::end == hash_map::begin.

Comentarios

end se usa para comprobar si un iterador ha llegado al final de su hash_map.

El valor devuelto por end no se debe desreferenciar.

Ejemplo

// hash_map_end.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_cIter = hm1.end( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is "
        << hm1_cIter -> second << "." << endl;

   hm1_Iter = hm1.end( );
   hm1_Iter--;
   hm1.erase ( hm1_Iter );

   // The following 2 lines would err because the iterator is const
   // hm1_cIter = hm1.end ( );
   // hm1_cIter--;
   // hm1.erase ( hm1_cIter );

   hm1_cIter = hm1.end( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is now "
        << hm1_cIter -> second << "." << endl;
}

The value of last element of hm1 is 30.
The value of last element of hm1 is now 20.

hash_map::equal_range

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve un par de iteradores respectivamente al primer elemento de hash_map cuya clave mayor es que una clave especificada y al primer elemento del hash_map cuya clave es igual o mayor que la clave especificada.

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

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

Parámetros

key
Valor de clave de argumento que se comparará con la clave de ordenación del elemento hash_map que se está buscando.

Valor devuelto

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

Para tener acceso al primer iterador de un par pr devuelto por la función miembro, use pr.first; para desreferenciar el iterador de límite inferior, use *(pr.first). Para tener acceso al segundo iterador de un par pr devuelto por la función miembro, use pr.second; para desreferenciar el iterador de límite superior, use *(pr.second).

Comentarios

Ejemplo

// hash_map_equal_range.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_map <int, int> IntMap;
   IntMap hm1;
   hash_map <int, int> :: const_iterator hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   pair <IntMap::const_iterator, IntMap::const_iterator> p1, p2;
   p1 = hm1.equal_range( 2 );

   cout << "The lower bound of the element with "
        << "a key of 2 in the hash_map hm1 is: "
        << p1.first -> second << "." << endl;

   cout << "The upper bound of the element with "
        << "a key of 2 in the hash_map hm1 is: "
        << p1.second -> second << "." << endl;

   // Compare the upper_bound called directly
   hm1_RcIter = hm1.upper_bound( 2 );

   cout << "A direct call of upper_bound( 2 ) gives "
        << hm1_RcIter -> second << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 2 )." << endl;

   p2 = hm1.equal_range( 4 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == hm1.end( ) ) && ( p2.second == hm1.end( ) ) )
      cout << "The hash_map hm1 doesn't have an element "
             << "with a key less than 40." << endl;
   else
      cout << "The element of hash_map hm1 with a key >= 40 is: "
           << p1.first -> first << "." << endl;
}

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

hash_map::erase

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Quita un elemento o un intervalo de elementos de una clase hash_map 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 quitará de hash_map.

first
Posición del primer elemento que se quitará de hash_map.

last
Posición inmediatamente siguiente a la del último elemento que se quitará de hash_map.

key
Valor de clave de los elementos que se van a quitar de hash_map.

Valor devuelto

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

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

Comentarios

Las funciones miembro nunca producen una excepción.

Ejemplo

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

// hash_map_erase.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1, hm2, hm3;
    hash_map<int, int> :: iterator pIter, Iter1, Iter2;
    int i;
    hash_map<int, int>::size_type n;
    typedef pair<int, int> Int_Pair;

    for (i = 1; i < 5; i++)
    {
        hm1.insert(Int_Pair (i, i));
        hm2.insert(Int_Pair (i, i*i));
        hm3.insert(Int_Pair (i, i-1));
    }

    // The 1st member function removes an element at a given position
    Iter1 = ++hm1.begin();
    hm1.erase(Iter1);

    cout << "After the 2nd element is deleted, the hash_map hm1 is:";
    for (pIter = hm1.begin(); pIter != hm1.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 2nd member function removes elements
    // in the range [ first,  last)
    Iter1 = ++hm2.begin();
    Iter2 = --hm2.end();
    hm2.erase(Iter1, Iter2);

    cout << "After the middle two elements are deleted, "
         << "the hash_map hm2 is:";
    for (pIter = hm2.begin(); pIter != hm2.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 3rd member function removes elements with a given  key
    n = hm3.erase(2);

    cout << "After the element with a key of 2 is deleted,\n"
         << "the hash_map hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 3rd member function returns the number of elements removed
    cout << "The number of elements removed from hm3 is: "
         << n << "." << endl;

    // The dereferenced iterator can also be used to specify a key
    Iter1 = ++hm3.begin();
    hm3.erase(Iter1);

    cout << "After another element with a key equal to that"
         << endl;
    cout  << "of the 2nd element is deleted, "
          << "the hash_map hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;
}

After the 2nd element is deleted, the hash_map hm1 is: 1 3 4.
After the middle two elements are deleted, the hash_map hm2 is: 1 16.
After the element with a key of 2 is deleted,
the hash_map hm3 is: 0 2 3.
The number of elements removed from hm3 is: 1.
After another element with a key equal to that
of the 2nd element is deleted, the hash_map hm3 is: 0 3.

hash_map::find

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

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

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parámetros

key
Valor de clave que debe coincidir con la clave de ordenación de un elemento de hash_map que se está buscando.

Valor devuelto

Iterador que se dirige a la primera ubicación de un elemento con una clave especificada, o la ubicación siguiente al último elemento de hash_map si no se encuentra ninguna coincidencia con la clave.

Comentarios

find devuelve un iterador que se dirige a un elemento de hash_map cuyo criterio de ordenación es equivalente a la clave de argumento de un predicado binario que induce a una ordenación basada en una relación de comparabilidad de menor que.

Si el valor devuelto de find se asigna a un const_iterator, hash_map no se puede modificar. Si el valor devuelto de find se asigna a un iterator, hash_map sí se puede modificar.

Ejemplo

// hash_map_find.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.find( 2 );
   cout << "The element of hash_map hm1 with a key of 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   hm1_RcIter = hm1.find( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_map can be found
   // using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.end( );
   hm1_AcIter--;
   hm1_RcIter = hm1.find( hm1_AcIter -> first );
   cout << "The element of hm1 with a key matching "
        << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;
}

The element of hash_map hm1 with a key of 2 is: 20.
The hash_map hm1 doesn't have an element with a key of 4.
The element of hm1 with a key matching that of the last element is: 30.

hash_map::get_allocator

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve una copia del objeto de asignador usado para construir hash_map.

Allocator get_allocator() const;

Valor devuelto

Asignador usado por hash_map.

Comentarios

Los asignadores de la clase hash_map especifican la forma en que la clase administra el almacenamiento. Los asignadores predeterminados proporcionados con las clases contenedoras de la biblioteca estándar de C++ son suficientes para la mayoría de las necesidades de programación. La escritura y el uso de sus propias clases de asignador son temas avanzados de C++.

Ejemplo

// hash_map_get_allocator.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int>::allocator_type hm1_Alloc;
   hash_map <int, int>::allocator_type hm2_Alloc;
   hash_map <int, double>::allocator_type hm3_Alloc;
   hash_map <int, int>::allocator_type hm4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   hash_map <int, int> hm1;
   hash_map <int, int> hm2;
   hash_map <int, double> hm3;

   hm1_Alloc = hm1.get_allocator( );
   hm2_Alloc = hm2.get_allocator( );
   hm3_Alloc = hm3.get_allocator( );

   cout << "The number of integers that can be allocated"
        << endl << "before free memory is exhausted: "
        << hm2.max_size( ) << "." << endl;

   cout << "The number of doubles that can be allocated"
        << endl << "before free memory is exhausted: "
        << hm3.max_size( ) <<  "." << endl;

   // The following line creates a hash_map hm4
   // with the allocator of hash_map hm1.
   hash_map <int, int> hm4( less<int>( ), hm1_Alloc );

   hm4_Alloc = hm4.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated with the other
   if( hm1_Alloc == hm4_Alloc )
   {
      cout << "The allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "The allocators are not interchangeable."
           << endl;
   }
}

hash_map::hash_map

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Crea un hash_map que está vacío o que es una copia de todo o de parte de otro hash_map.

hash_map();

explicit hash_map(
    const Traits& Comp);

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

hash_map(
    const hash_map& Right);

hash_map(
    hash_map&& Right);

hash_map(
    initializer_list<Type> IList);hash_map(initializer_list<Type> IList,
    const key_compare& Comp);

hash_map(
    initializer_list<Type> IList,
    const key_compare& Comp,
    const allocator_type& Al);

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

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

template <class InputIterator>
hash_map(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp,
    const Allocator& Al

Parámetros

Al
Clase de asignador de almacenamiento que se va a utilizar para este objeto hash_map, que toma como valor predeterminado Allocator.

Comp
Función de comparación de tipo const Traits que se utiliza para ordenar los elementos de hash_map, que toma como valor predeterminado hash_compare.

Right
hash_map del que la asignación creada va a ser una copia.

First
Posición del primer elemento en el intervalo de elementos que se va a copiar.

Last
Posición del primer elemento más allá del intervalo de elementos que se va a copiar.

IList
El initializer_list

Comentarios

Todos los constructores almacenan un tipo de objeto de asignador que administra el almacenamiento de hash_map y que se puede devolver más adelante llamando a 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 objetos hash_map.

Todos los constructores almacenan un objeto de función de tipo Traits que se utiliza para establecer un orden entre las claves de hash_map y que se puede devolver más adelante llamando a key_comp.

Los tres primeros constructores especifican un objeto hash_map inicial vacío, además, el segundo especifica el tipo de función de comparación (Comp) que se usará para establecer el orden de los elementos y el tercero especifica de forma explícita el tipo de asignador (Al) que se va a usar. La palabra clave explicit suprime ciertas clases de conversión automática de tipos.

El cuarto constructor especifica una copia de .hash_map Right

Los tres constructores siguientes copian el intervalo [First, Last) de un hash_map especificando de forma cada vez más explícita el tipo de función de comparación de clase Traits y el asignador.

El último constructor mueve .hash_map Right

hash_map::insert

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

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

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

iterator insert(
    const_iterator _Where,
    const value_type& val);

template <class InputIterator>
void insert(
    InputIterator first,
    InputIterator last);

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

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

Parámetros

val
Valor de un elemento que se va a insertar en el hash_map a menos que hash_map ya contenga ese elemento o, más general, un elemento cuya clave esté ordenada de manera equivalente.

_Where
Sugerencia con respecto al lugar donde se va a empezar a buscar el punto correcto de inserción.

first
Posición del primer elemento que se va a copiar de un hash_map.

last
Posición situada más allá del último elemento que se va a copiar de un hash_map.

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_map 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, la versión de sugerencia, devuelve un iterador que apunta a la posición donde se ha insertado el nuevo elemento en hash_map.

Las dos últimas funciones miembro insert se comportan igual que las dos primeras, salvo que construyen con movimiento el valor insertado.

Comentarios

El value_type de un elemento es un par, de modo que el valor de un elemento será un par ordenado en el que el primer componente es igual que el valor de clave y el segundo componente es igual que el valor de datos del elemento.

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.

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

Ejemplo

// hash_map_insert.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int>::iterator hm1_pIter, hm2_pIter;

    hash_map<int, int> hm1, hm2;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 10));
    hm1.insert(Int_Pair(2, 20));
    hm1.insert(Int_Pair(3, 30));
    hm1.insert(Int_Pair(4, 40));

    cout << "The original elements (Key => Value) of hm1 are:";
    for (hm1_pIter = hm1.begin(); hm1_pIter != hm1.end(); hm1_pIter++)
        cout << endl << " " << hm1_pIter -> first << " => "
             << hm1_pIter->second;
    cout << endl;

    pair< hash_map<int,int>::iterator, bool > pr;
    pr = hm1.insert(Int_Pair(1, 10));

    if (pr.second == true)
    {
        cout << "The element 10 was inserted in hm1 successfully."
            << endl;
    }
    else
    {
        cout << "The element 10 already exists in hm1\n"
            << "with a key value of "
            << "((pr.first) -> first) = " << (pr.first)->first
            << "." << endl;
    }

    // The hint version of insert
    hm1.insert(--hm1.end(), Int_Pair(5, 50));

    cout << "After the insertions, the elements of hm1 are:";
    for (hm1_pIter = hm1.begin(); hm1_pIter != hm1.end(); hm1_pIter++)
        cout << endl << hm1_pIter -> first << " => "
             << hm1_pIter->second;
    cout << endl;

    hm2.insert(Int_Pair(10, 100));

    // The templatized version inserting a range
    hm2.insert( ++hm1.begin(), --hm1.end() );

    cout << "After the insertions, the elements of hm2 are:";
    for (hm2_pIter = hm2.begin(); hm2_pIter != hm2.end(); hm2_pIter++)
        cout << endl << hm2_pIter -> first << " => "
             << hm2_pIter->second;
    cout << endl;

    // The templatized versions move constructing elements
    hash_map<int, string> hm3, hm4;
    pair<int, string> is1(1, "a"), is2(2, "b");

    hm3.insert(move(is1));
    cout << "After the move insertion, hm3 contains:" << endl
      << hm3.begin()->first
      << " => " << hm3.begin()->second
      << endl;

    hm4.insert(hm4.begin(), move(is2));
    cout << "After the move insertion, hm4 contains:" << endl
      << hm4.begin()->first
      << " => " << hm4.begin()->second
      << endl;
}

The original elements (Key => Value) of hm1 are:
1 => 10
2 => 20
3 => 30
4 => 40
The element 10 already exists in hm1
with a key value of ((pr.first) -> first) = 1.
After the insertions, the elements of hm1 are:
1 => 10
2 => 20
3 => 30
4 => 40
5 => 50
After the insertions, the elements of hm2 are:
2 => 20
10 => 100
3 => 30
4 => 40
After the move insertion, hm3 contains:
1 => a
After the move insertion, hm4 contains:
2 => b

hash_map::iterator

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo que proporciona un iterador bidireccional que puede leer o modificar cualquier elemento de hash_map.

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

Comentarios

El elemento iterator definido mediante hash_map apunta a elementos que son value_type, esto es, que son de tipo pair<const Key, Type>, cuyo primer miembro es la clave del elemento y el segundo, la referencia asignada que el elemento conserva.

Para desreferenciar un iterador denominado Iter que señala a un elemento de una asignación múltiple, use el operador ->.

Para tener acceso al valor de clave del elemento, use Iter->first, que equivale a (*Iter).first. Para tener acceso al valor de la referencia asignada del elemento, use Iter->second, que equivale a (*Iter).second.

Se puede usar un tipo iterator para modificar el valor de un elemento.

Ejemplo

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

hash_map::key_comp

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

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

key_compare key_comp() const;

Valor devuelto

Devuelve el objeto de función que hash_map usa para ordenar sus elementos.

Comentarios

El objeto almacenado define la función miembro

bool operator( const Key& left, const Key&right );

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

Ejemplo

// hash_map_key_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_map <int, int, hash_compare<int, less<int> > > hm1;
   hash_map <int, int, hash_compare<int, less<int> > >::key_compare
      kc1 = hm1.key_comp( ) ;

   // Operator stored in kc1 tests order & returns bool value
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true,"
           << "\n where kc1 is the function object of hm1"
           << " of type key_compare." << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false"
           << "\n where kc1 is the function object of hm1"
           << " of type key_compare." << endl;
   }

   hash_map <int, int, hash_compare<int, greater<int> > > hm2;
   hash_map <int, int, hash_compare<int, greater<int> > >
      ::key_compare kc2 = hm2.key_comp( );

   // Operator stored in kc2 tests order & returns bool value
   bool result2 = kc2( 2, 3 ) ;
   if( result2 == true )
   {
      cout << "kc2( 2,3 ) returns value of true,"
           << "\n where kc2 is the function object of hm2"
           << " of type key_compare." << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false,"
           << "\n where kc2 is the function object of hm2"
           << " of type key_compare." << endl;
   }
}

hash_map::key_compare

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo que proporciona un objeto de función que puede comparar dos criterios de ordenación para determinar el orden relativo de dos elementos del mapa.

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, vea el tema hash_map (Clase).

Ejemplo

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

hash_map::key_type

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo que describe el objeto de clave de ordenación que constituye cada elemento de hash_map.

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 del tema hash_map (Clase).

Ejemplo

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

hash_map::lower_bound

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve un iterador al primer elemento de hash_map cuyo valor de clave es igual o mayor que el de una clave especificada.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parámetros

key
Valor de clave de argumento que se comparará con la clave de ordenación del elemento hash_map que se está buscando.

Valor devuelto

iterator o const_iterator que direcciona la ubicación de un elemento de hash_map que tiene una clave igual o mayor que la clave de argumento o que direcciona la ubicación siguiente al último elemento de hash_map si no se encuentra ninguna coincidencia con la clave.

Si el valor devuelto de lower_bound se asigna a un const_iterator, hash_map no se puede modificar. Si el valor devuelto de lower_bound se asigna a un iterator, hash_map sí se puede modificar.

Comentarios

Ejemplo

// hash_map_lower_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.lower_bound( 2 );
   cout << "The first element of hash_map hm1 with a key of 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   hm1_RcIter = hm1. lower_bound ( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // An element at a specific location in the hash_map can be
   // found using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.end( );
   hm1_AcIter--;
   hm1_RcIter = hm1. lower_bound ( hm1_AcIter -> first );
   cout << "The element of hm1 with a key matching "
        << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;
}

The first element of hash_map hm1 with a key of 2 is: 20.
The hash_map hm1 doesn't have an element with a key of 4.
The element of hm1 with a key matching that of the last element is: 30.

hash_map::mapped_type

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo que representa el tipo de datos almacenados en un hash_map.

typedef Type mapped_type;

Comentarios

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

Para obtener más información sobre Type, vea el tema hash_map (Clase).

Ejemplo

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

hash_map::max_size

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve la longitud máxima del hash_map.

size_type max_size() const;

Valor devuelto

Longitud máxima posible de hash_map.

Comentarios

Ejemplo

// hash_map_max_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: size_type i;

   i = hm1.max_size( );
   cout << "The maximum possible length "
        << "of the hash_map is " << i << "."
        << endl << "(Magnitude is machine specific.)";
}

hash_map::operator[]

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Inserta un elemento en un hash_map con un valor de clave especificado.

Type& operator[](const Key& key);

Type& operator[](Key&& key);

Parámetros

key
El valor de clave del elemento que se tiene que insertar.

Valor devuelto

Referencia al valor de datos del elemento insertado.

Comentarios

Si el valor de clave de argumento no se encuentra, se inserta junto con el valor predeterminado del tipo de datos.

operator[] puede usarse para insertar elementos en un hash_map m con

m[ key] = DataValue;

donde DataValue es el valor del mapped_type del elemento con un valor de clave de key.

Cuando se emplea operator[] para insertar elementos, la referencia devuelta no indica si una inserción cambia un elemento ya existente o crea uno nuevo. Se pueden usar las funciones miembro find e insert para determinar si ya existe un elemento con una clave especificada antes de una inserción.

Ejemplo

// hash_map_op_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;
   hash_map <int, int> :: iterator pIter;

   // Insert a data value of 10 with a key of 1
   // into a hash_map using the operator[] member function
   hm1[ 1 ] = 10;

   // Compare other ways to insert objects into a hash_map
   hm1.insert ( hash_map <int, int> :: value_type ( 2, 20 ) );
   hm1.insert ( cInt2Int ( 3, 30 ) );

   cout  << "The keys of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;

   // If the key already exists, operator[]
   // changes the value of the datum in the element
   hm1[ 2 ] = 40;

   // operator[] will also insert the value of the data
   // type's default constructor if the value is unspecified
   hm1[5];

   cout  << "The keys of the mapped elements are now:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are now:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;

   // operator[] will also insert by moving a key
   hash_map <string, int> hm2;
   string str("a");
   hm2[move(str)] = 1;
   cout << "The moved key is " << hm2.begin()->first
      << ", with value " << hm2.begin()->second << endl;
}

hash_map::operator=

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Reemplaza los elementos del hash_map con una copia de otro hash_map.

hash_map& operator=(const hash_map& right);

hash_map& operator=(hash_map&& right);

Parámetros

right
Clase right que se copia en hash_map.

Comentarios

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

Ejemplo

// hash_map_operator_as.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map<int, int> v1, v2, v3;
   hash_map<int, int>::iterator iter;

   v1.insert(pair<int, int>(1, 10));

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << iter->second << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter->second << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter->second << " ";
   cout << endl;
}

hash_map::pointer

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo que proporciona un puntero a un elemento de hash_map.

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

Comentarios

Se puede usar un tipo pointer para modificar el valor de un elemento.

En la mayoría de los casos, se debe usar iterator para obtener acceso a los elementos de un objeto hash_map.

hash_map::rbegin

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve un iterador que direcciona el primer elemento de hash_map invertido.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor devuelto

Iterador bidireccional inverso que direcciona al primer elemento de un hash_map invertido o a lo que fue el último elemento de hash_map sin invertir.

Comentarios

rbegin se usa con un hash_map invertido igual que begin se usa con un hash_map.

Si el valor devuelto de rbegin se asigna a un const_reverse_iterator, hash_map no se puede modificar. Si el valor devuelto de rbegin se asigna a un reverse_iterator, hash_map sí se puede modificar.

rbegin puede usarse para iterar un objeto hash_map hacia atrás.

Ejemplo

// hash_map_rbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: reverse_iterator hm1_rIter;
   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_rIter = hm1.rbegin( );
   cout << "The first element of the reversed hash_map hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_map in a forward order
   cout << "The hash_map is: ";
   for ( hm1_Iter = hm1.begin( ) ; hm1_Iter != hm1.end( ); hm1_Iter++)
      cout << hm1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a hash_map in a reverse order
   cout << "The reversed hash_map is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_map element can be erased by dereferencing to its key
   hm1_rIter = hm1.rbegin( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed hash_map is "
        << hm1_rIter -> first << "." << endl;
}

The first element of the reversed hash_map hm1 is 3.
The hash_map is: 1 2 3 .
The reversed hash_map is: 3 2 1 .
After the erasure, the first element in the reversed hash_map is 2.

hash_map::reference

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo que proporciona una referencia a un elemento almacenado en un hash_map.

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

Comentarios

Ejemplo

// hash_map_reference.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( hm1.begin( ) -> first );

   // The following line would cause an error as the
   // non-const_reference cannot be used to access the key
   // int &Ref1 = ( hm1.begin( ) -> first );

   cout << "The key of first element in the hash_map is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( hm1.begin( ) -> second );

   cout << "The data value of first element in the hash_map is "
        << Ref2 << "." << endl;

   // The non-const_reference can be used to modify the
   // data value of the first element
   Ref2 = Ref2 + 5;
   cout << "The modified data value of first element is "
        << Ref2 << "." << endl;
}

The key of first element in the hash_map is 1.
The data value of first element in the hash_map is 10.
The modified data value of first element is 15.

hash_map::rend

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve un iterador que direcciona la ubicación que sigue al último elemento de hash_map invertido.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valor devuelto

Iterador bidireccional inverso que dirige a la ubicación siguiente al último elemento de un hash_map invertido (la ubicación que había precedido al primer elemento de hash_map sin invertir).

Comentarios

rend se usa con un hash_map invertido igual que end se usa con un hash_map.

Si el valor devuelto de rend se asigna a un const_reverse_iterator, hash_map no se puede modificar. Si el valor devuelto de rend se asigna a un reverse_iterator, hash_map sí se puede modificar.

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

El valor devuelto por rend no se debe desreferenciar.

Ejemplo

// hash_map_rend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: reverse_iterator hm1_rIter;
   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_rIter = hm1.rend( );
   hm1_rIter--;
   cout << "The last element of the reversed hash_map hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_map in a forward order
   cout << "The hash_map is: ";
   for ( hm1_Iter = hm1.begin( ) ; hm1_Iter != hm1.end( );
   hm1_Iter++)
      cout << hm1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a hash_map in a reverse order
   cout << "The reversed hash_map is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( );
      hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_map element can be erased by dereferencing to its key
   hm1_rIter = --hm1.rend( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rend( );
   hm1_rIter--;
   cout << "After the erasure, the last element "
        << "in the reversed hash_map is "
        << hm1_rIter -> first << "." << endl;
}

The last element of the reversed hash_map hm1 is 1.
The hash_map is: 1 2 3 .
The reversed hash_map is: 3 2 1 .
After the erasure, the last element in the reversed hash_map is 2.

hash_map::reverse_iterator

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo que proporciona un iterador bidireccional que puede leer o modificar un elemento de hash_map invertido.

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

Comentarios

Un tipo reverse_iterator no puede modificar el valor de un elemento y se usa para iterar por hash_map en orden inverso.

El elemento reverse_iterator definido mediante hash_map apunta a elementos que son value_type, esto es, que son de tipo pair<const Key, Type>, cuyo primer miembro es la clave del elemento y el segundo, la referencia asignada que el elemento conserva.

Para desreferenciar un reverse_iterator rIter que apunta a un elemento de , hash_mapuse el -> operador .

Para tener acceso al valor de clave del elemento, use rIter->first, que equivale a (*rIter).first. Para tener acceso al valor de la referencia asignada del elemento, use rIter->second, que equivale a (*rIter).first.

Ejemplo

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

hash_map::size

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve el número de elementos de hash_map.

size_type size() const;

Valor devuelto

Longitud actual de hash_map.

Comentarios

Ejemplo

En el ejemplo siguiente se muestra el uso de la función miembro hash_map::size.

// hash_map_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1, hm2;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 1));
    i = hm1.size();
    cout << "The hash_map length is " << i << "." << endl;

    hm1.insert(Int_Pair(2, 4));
    i = hm1.size();
    cout << "The hash_map length is now " << i << "." << endl;
}

The hash_map length is 1.
The hash_map length is now 2.

hash_map::size_type

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo entero sin signo que puede representar el número de elementos de un hash_map.

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

Comentarios

Ejemplo

Vea el ejemplo de size para obtener un ejemplo de cómo declarar y usar size_type.

hash_map::swap

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Intercambia los elementos de dos hash_map.

void swap(hash_map& right);

Parámetros

right
Objeto hash_map de argumento que proporciona los elementos que se van a intercambiar con el objeto hash_map de destino.

Comentarios

La función miembro no invalida ninguna referencia, puntero o iterador que designe elementos de los dos objetos hash_map cuyos elementos se intercambian.

Ejemplo

// hash_map_swap.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1, hm2, hm3;
   hash_map <int, int>::iterator hm1_Iter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );
   hm2.insert ( Int_Pair ( 10, 100 ) );
   hm2.insert ( Int_Pair ( 20, 200 ) );
   hm3.insert ( Int_Pair ( 30, 300 ) );

   cout << "The original hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;

   // This is the member function version of swap
   // hm2 is said to be the argument hash_map;
   // hm1 is said to be the target hash_map
   hm1.swap( hm2 );

   cout << "After swapping with hm2, hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hm1, hm3 );

   cout << "After swapping with hm3, hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;
}

The original hash_map hm1 is: 10 20 30.
After swapping with hm2, hash_map hm1 is: 100 200.
After swapping with hm3, hash_map hm1 is: 300.

hash_map::upper_bound

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve un iterador al primer elemento de hash_map cuyo valor de clave es mayor que el de una clave especificada.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parámetros

key
Valor de clave de argumento que se comparará con el valor de clave de ordenación del hash_map que se está buscando.

Valor devuelto

iterator o const_iterator que dirige a la ubicación de un elemento de hash_map que tiene una clave mayor que la clave de argumento o que dirige a la ubicación siguiente al último elemento de hash_map si no se encuentra ninguna coincidencia con la clave.

Si el valor devuelto se asigna a const_iterator, hash_map no se puede modificar. Si el valor devuelto se asigna a iterator, hash_map sí se puede modificar.

Comentarios

Ejemplo

// hash_map_upper_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.upper_bound( 2 );
   cout << "The first element of hash_map hm1 with a key "
        << "greater than 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end is returned
   hm1_RcIter = hm1. upper_bound ( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key greater than 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key > 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_map can be found
   // using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.begin( );
   hm1_RcIter = hm1. upper_bound ( hm1_AcIter -> first );
   cout << "The 1st element of hm1 with a key greater than that\n"
        << "of the initial element of hm1 is: "
        << hm1_RcIter -> second << "." << endl;
}

The first element of hash_map hm1 with a key greater than 2 is: 30.
The hash_map hm1 doesn't have an element with a key greater than 4.
The 1st element of hm1 with a key greater than that
of the initial element of hm1 is: 20.

hash_map::value_comp

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Devuelve un objeto de función que determina el orden de los elementos de un hash_map mediante la comparación de sus valores de clave.

value_compare value_comp() const;

Valor devuelto

Devuelve el objeto de función de comparación que hash_map usa para ordenar sus elementos.

Comentarios

Para , si dos elementos e1 (k1, d1) y e2 (k2, d2) son objetos de tipo value_type, donde k1 y k2 son sus claves de tipo key_type y d1 son d2 sus datos de tipo mapped_type, entonces m.value_comp()(e1, e2) es equivalente a m.key_comp()(k1, k2).hash_map m Un objeto almacenado define la función miembro

bool operator(value_type& left, value_type& right);

que devuelve true si el valor de clave de left precede y no es igual al valor de clave de right en el criterio de ordenación.

Ejemplo

// hash_map_value_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_map <int, int, hash_compare<int, less<int> > > hm1;
   hash_map <int, int, hash_compare<int, less<int> > >
   ::value_compare vc1 = hm1.value_comp( );
   pair< hash_map<int,int>::iterator, bool > pr1, pr2;

   pr1= hm1.insert ( hash_map <int, int> :: value_type ( 1, 10 ) );
   pr2= hm1.insert ( hash_map <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *pr1.first, *pr2.first ) == true )
   {
      cout << "The element ( 1,10 ) precedes the element ( 2,5 )."
           << endl;
   }
   else
   {
      cout << "The element ( 1,10 ) does not precede the element ( 2,5 )."
           << endl;
   }

   if( vc1 ( *pr2.first, *pr1.first ) == true )
   {
      cout << "The element ( 2,5 ) precedes the element ( 1,10 )."
           << endl;
   }
   else
   {
      cout << "The element ( 2,5 ) does not precede the element ( 1,10 )."
           << endl;
   }
}

hash_map::value_type

Nota:

Esta API está obsoleta. La alternativa es la clase unordered_map.

Tipo que representa el tipo de objeto almacenado en un hash_map.

typedef pair<const Key, Type> value_type;

Comentarios

value_type se declara como pair<const key_type, mapped_type> y no como pair<key_type, mapped_type> porque las claves de un contenedor asociativo no se pueden cambiar mediante una referencia o un iterador no constante.

Ejemplo

// hash_map_value_type.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;
   hash_map <int, int> :: key_type key1;
   hash_map <int, int> :: mapped_type mapped1;
   hash_map <int, int> :: value_type value1;
   hash_map <int, int> :: iterator pIter;

   // value_type can be used to pass the correct type
   // explicitly to avoid implicit type conversion
   hm1.insert ( hash_map <int, int> :: value_type ( 1, 10 ) );

   // Compare other ways to insert objects into a hash_map
   hm1.insert ( cInt2Int ( 2, 20 ) );
   hm1[ 3 ] = 30;

   // Initializing key1 and mapped1
   key1 = ( hm1.begin( ) -> first );
   mapped1 = ( hm1.begin( ) -> second );

   cout << "The key of first element in the hash_map is "
        << key1 << "." << endl;

   cout << "The data value of first element in the hash_map is "
        << mapped1 << "." << endl;

   // The following line would cause an error because
   // the value_type is not assignable
   // value1 = cInt2Int ( 4, 40 );

   cout  << "The keys of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;
}

The key of first element in the hash_map is 1.
The data value of first element in the hash_map is 10.
The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 30.

Vea también

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