Classe hash_map

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Armazena e recupera dados rapidamente de uma coleção em que cada elemento é um par que tem uma chave de classificação cujo valor é exclusivo, bem como um valor de dados associado.

Sintaxe

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
O tipo de dados da chave a ser armazenado no hash_map.

Type
O tipo de dados do elemento a ser armazenado no hash_map.

Traits
O tipo que inclui dois objetos de função: um da classe compare, para comparar dois valores de elemento como chaves de classificação para determinar sua ordem relativa e uma função de hash, que é um predicado unário que mapeia valores chave dos elementos para inteiros sem sinal do tipo size_t. Esse argumento é opcional e hash_compare<Key, less<Key>> é o valor padrão.

Allocator
O tipo que representa o objeto de alocador armazenado que encapsula detalhes sobre a alocação e a desalocação do hash_map da memória. Esse argumento é opcional e o valor padrão é allocator<pair <const Key, Type>>.

Comentários

O hash_map é:

• Um contêiner associativo, que é um contêiner de tamanho variável que oferece suporte à recuperação eficiente dos valores de elemento com base em um valor de chave associado.

• Reversível, pois fornece um iterador bidirecional para acessar seus elementos.

• Com hash, pois seus elementos são agrupados em buckets com base no valor de uma função de hash aplicada aos valores chave dos elementos.

• Exclusivo no sentido de que cada um de seus elementos deve ter uma chave exclusiva.

• Um contêiner de par associativo, pois seus valores de dados de elemento são distintos de seus valores de chave.

• Um modelo de classe, pois a funcionalidade fornecida por ela é genérica e, portanto, independente do tipo de dados específico contido como elementos ou chaves. Os tipos de dados a serem usados para elementos e chaves são especificados como parâmetros no modelo de classe juntamente com o alocador e a função de comparação.

A principal vantagem do uso de hash em vez da classificação é a maior eficiência: um hash bem-sucedido executa inserções, exclusões e localizações em tempos médios constantes, em comparação com um tempo proporcional ao logaritmo do número de elementos no contêiner para técnicas de classificação. O valor de um elemento em um hash_map, mas não seu valor de chave associado, pode ser alterado diretamente. Em vez disso, os valores de chave associados aos elementos antigos devem ser excluídos e os novos valores de chave associados aos novos elementos inseridos.

A escolha do tipo de contêiner deve se basear, de modo geral, no tipo de pesquisa e inserção exigido pelo aplicativo. Contêineres associativos com hash são otimizados para as operações de pesquisa, inserção e remoção. As funções membro que dão suporte explicitamente a essas operações são eficientes quando usadas com uma função de hash bem elaborada, executando-as em um tempo que é, em média, constante e não dependente do número de elementos no contêiner. Uma função de hash bem elaborada produz uma distribuição uniforme de valores em hash e minimiza o número de colisões, em que uma colisão deve ocorrer quando valores de chave distintos são mapeados para o mesmo valor em hash. No pior caso, com a pior função de hash possível, o número de operações será proporcional ao número de elementos na sequência (tempo linear).

O hash_map deve ser o contêiner associativo escolhido quando as condições que associam os valores às respectivas chaves forem atendidas pelo aplicativo. Um modelo para esse tipo de estrutura é uma lista ordenada de palavras-chave que ocorrem uma única vez e com valores de cadeia de caracteres associados que forneçam definições. Se as palavras tiverem mais de uma definição correta, as chave não seriam exclusivas, de modo que um hash_multimap seria o contêiner ideal. Se, por outro lado, apenas as listas de palavras foram sendo armazenadas, um hash_set seria o contêiner correto. Se não foram permitidas as várias ocorrências das palavras, um hash_multiset seria a estrutura de contêiner apropriada.

O hash_map ordena a sequência que controla chamando um objeto Traits de hash armazenado da classe value_compare. Esse objeto armazenado pode ser acessado chamando a função membro key_comp. Um objeto de função precisa se comportar da mesma forma que um objeto da classe hash_compare<Key, less<Key>>. Especificamente, para todos os valores de Key do tipo Key, a chamada Traits( Key ) produz uma distribuição de valores do tipo size_t. Para obter mais informações, consulte hash_compare.

De modo geral, os elementos precisam ser simplesmente menores que os comparáveis para estabelecer essa ordem: desse modo, considerando dois elementos, pode ser determinado que, ou eles são equivalentes (no sentido de que nenhum deles é menor que o outro), ou que um é menor que o outro. Isso resulta em uma ordenação entre os elementos não equivalentes. Fazendo uma observação mais técnica, a função de comparação é um predicado binário que induz a uma ordenação fraca restrita no sentido matemático padrão. Um predicado binário f(x,y) é um objeto de função que tem dois objetos de argumento x e y e um valor retornado de true ou false. Uma ordenação imposta a um hash_map será uma ordenação fraca restrita se o predicado binário for irreflexivo, antissimétrico e transitivo e se a equivalência for transitiva, em que dois objetos x e y são definidos para serem equivalentes quando f( x, y) e f( y, x) forem false. Se a condição mais forte de igualdade entre as chaves substituir essa equivalência, a ordenação será total (no sentido de que todos os elementos serão ordenados um em relação ao outro) e as chaves correspondentes não poderão ser diferenciadas uma da outra.

A ordem real dos elementos na sequência controlada depende da função de hash, da função de ordenação e do tamanho atual da tabela de hash armazenada no objeto de contêiner. Você não pode determinar o tamanho atual da tabela de hash, portanto, não pode, em geral, prever a ordem dos elementos na sequência controlada. A inserção de elementos não invalida iteradores e a remoção de elementos invalida apenas os iteradores que apontavam especificamente os elementos removidos.

O iterador fornecido pela classe hash_map é um iterador bidirecional, mas as funções membro de classe insert e hash_map têm versões que usam como parâmetros de modelo um iterador de entrada mais fraco, cujos requisitos de funcionalidade são mais minimalistas do que aqueles assegurados pela classe de iteradores bidirecionais. Os conceitos de iterador diferente formam uma família relacionada por refinamentos em sua funcionalidade. Cada conceito de iterador tem seu próprio conjunto de requisitos e os algoritmos que funcionam com eles devem limitar suas suposições para os requisitos fornecidos por esse tipo de iterador. Pode ser pressuposto que um iterador de entrada possa ser desreferenciado para fazer referência a algum objeto e que possa ser incrementado para o próximo iterador na sequência. Esse é um conjunto mínimo de funcionalidade, mas é suficiente para poder expressar de forma significativa um intervalo de iteradores [First, Last) no contexto de funções membro da classe.

Construtores

Construtor	Descrição
hash_map	Constrói um hash_map que está vazio ou que é uma cópia de todo ou parte de algum outro hash_map.

Typedefs

Nome do tipo	Descrição
allocator_type	Um tipo que representa a classe allocator para o objeto hash_map.
const_iterator	Um tipo que fornece um iterador bidirecional que pode ler um elemento const no hash_map.
const_pointer	Um tipo que fornece um ponteiro para um elemento const em um hash_map.
const_reference	Um tipo que fornece uma referência para um elemento const armazenado em um hash_map para leitura e execução de operações const.
const_reverse_iterator	Um tipo que fornece um iterador bidirecional que pode ler qualquer elemento const no hash_map.
difference_type	Um tipo de inteiro com sinal que pode ser usado para representar o número de elementos de um hash_map em um intervalo entre os elementos apontado pelos iteradores.
iterator	Um tipo que fornece um iterador bidirecional que pode ler ou modificar qualquer elemento em um hash_map.
key_compare	Um tipo que fornece um objeto de função que pode comparar duas chaves de classificação para determinar a ordem relativa de dois elementos no hash_map.
key_type	Um tipo que descreve o objeto de chave de classificação que constitui cada elemento do hash_map.
mapped_type	Um tipo que representa o tipo de dados armazenado em um hash_map.
pointer	Um tipo que fornece um ponteiro para um elemento em um hash_map.
reference	Um tipo que fornece uma referência a um elemento armazenado em um hash_map.
reverse_iterator	Um tipo que fornece um iterador bidirecional que pode ler ou modificar um elemento em um hash_map invertido.
size_type	Um tipo de inteiro sem sinal que pode representar o número de elementos em um hash_map.
value_type	Um tipo que fornece um objeto de função que pode comparar dois elementos como chaves de classificação para determinar sua ordem relativa no hash_map.

Funções de membro

Função de membro	Descrição
at	Localiza um elemento em um hash_map com um valor de chave especificado.
begin	Retorna um iterador que trata o primeiro elemento no hash_map.
cbegin	Retorna um iterador const que trata o primeiro elemento no hash_map.
cend	Retorna um iterador const que trata o local após o último elemento em um hash_map.
clear	Apaga todos os elementos de um hash_map.
count	Retorna o número de elementos em um hash_map cuja chave corresponde a uma chave especificada pelo parâmetro.
crbegin	Retorna um iterador const que trata o primeiro elemento em um hash_map invertido.
crend	Retorna um iterador const que trata o local após o último elemento em um hash_map invertido.
emplace	Insere um elemento construído adequadamente em um hash_map.
emplace_hint	Insere um elemento construído adequadamente em um hash_map, com uma dica de posicionamento.
empty	Testa se hash_map está vazio.
end	Retorna um iterador que trata o local após o último elemento em um hash_map.
equal_range	Retorna um par de iteradores, respectivamente, para o primeiro elemento em um hash_map com uma chave que é maior do que uma chave especificada e para o primeiro elemento no hash_map com uma chave igual ou maior que a chave.
erase	Remove um elemento ou um intervalo de elementos em um hash_map das posições especificadas
find	Retorna um iterador que trata do local de um elemento em um hash_map que tem uma chave equivalente a uma chave especificada.
get_allocator	Retorna uma cópia do objeto allocator usada para construir o hash_map.
insert	Insere um elemento ou um intervalo de elementos em um hash_map.
key_comp	Retorna um iterador para o primeiro elemento em um hash_map com um valor de chave que é igual ou maior que uma chave especificada.
lower_bound	Retorna um iterador para o primeiro elemento em um hash_map com um valor de chave que é igual ou maior que uma chave especificada.
max_size	Retorna o comprimento máximo do hash_map.
rbegin	Retorna um iterador que trata o primeiro elemento em um hash_map invertido.
rend	Retorna um iterador que trata o local após o último elemento em um hash_map invertido.
size	Retorna o número de elementos no hash_map.
swap	Troca os elementos de dois hash_maps.
upper_bound	Retorna um iterador para o primeiro elemento em um hash_map que tem um valor de chave que é maior que uma chave especificada.
value_comp	Recupera uma cópia do objeto de comparação usado para ordenar valores de elemento em um hash_map.

Operadores

Operador	Descrição
operator[]	Insere um elemento em um hash_map com um valor de chave especificado.
hash_map::operator=	Substitui os elementos de um hash_map por uma cópia de outro hash_map.

Requisitos

Cabeçalho: <hash_map>

Namespace: stdext

hash_map::allocator_type

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo que representa a classe allocator do objeto hash_map.

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

Exemplo

Veja o exemplo de get_allocator para obter um exemplo que usa allocator_type.

hash_map::at

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Localiza um elemento em um hash_map com um valor de chave especificado.

Type& at(const Key& key);

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

Parâmetros

key
O valor de chave do elemento que deve ser encontrado.

Valor de retorno

Uma referência ao valor de dados do elemento encontrado.

Comentários

Se o valor da chave do argumento não for encontrado, a função lançará um objeto da classe out_of_range Classe.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna um iterador que trata o primeiro elemento no hash_map.

const_iterator begin() const;

iterator begin();

Valor de retorno

Um iterador bidirecional que trata o primeiro elemento no hash_map ou o local após um hash_map vazio.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna um iterador const que trata o primeiro elemento no hash_map.

const_iterator cbegin() const;

Valor de retorno

Um iterador bidirecional const que trata o primeiro elemento no hash_map ou o local após um hash_map vazio.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna um iterador const que trata o local após o último elemento em um hash_map.

const_iterator cend() const;

Valor de retorno

Retorna um iterador bidirecional const que trata o local após o último elemento em um hash_map. Se o hash_map estiver vazio, então hash_map::cend == hash_map::begin.

Comentários

cend é usado para testar se um iterador atingiu o fim de seu hash_map.

O valor retornado por cend não deve ser desreferenciado.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Apaga todos os elementos de um hash_map.

void clear();

Comentários

Exemplo

O exemplo a seguir demonstra o uso da função de membro 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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo que fornece um iterador bidirecional que pode ler um elemento const no hash_map.

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

Comentários

Um tipo const_iterator não pode ser usado para modificar o valor de um elemento.

O const_iterator definido por hash_map aponta para elementos que são objetos de value_type, que são do tipo pair< const Key, Type >, cujo primeiro membro é a chave para o elemento e o segundo membro é a referência mapeada mantida pelo elemento.

Para desreferenciar um const_iterator cIter apontamento para um elemento em um hash_map, use o -> operador.

Para acessar o valor de chave do elemento, use cIter->first, que é equivalente a (*cIter).first. Para acessar o valor dos dados mapeados do elemento, use cIter->second, que é equivalente a (*cIter).second.

Exemplo

Veja o exemplo de begin para obter um exemplo que usa const_iterator.

hash_map::const_pointer

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo que fornece um ponteiro para um elemento const em um hash_map.

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

Comentários

Um tipo const_pointer não pode ser usado para modificar o valor de um elemento.

Na maioria dos casos, um iterator deve ser usado para acessar os elementos em um objeto hash_map.

hash_map::const_reference

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo que fornece uma referência para um elemento const armazenado em um hash_map para leitura e execução de operações const.

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

Comentários

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo que fornece um iterador bidirecional que pode ler qualquer elemento const no hash_map.

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

Comentários

Um tipo const_reverse_iterator não pode modificar o valor de um elemento e é usado para iterar o hash_map invertido.

O const_reverse_iterator definido por hash_map aponta para elementos que são objetos de value_type, que são do tipo pair< const Key, Type >, cujo primeiro membro é a chave para o elemento e o segundo membro é a referência mapeada mantida pelo elemento.

Para desreferenciar um const_reverse_iterator crIter apontamento para um elemento em um hash_map, use o -> operador.

Para acessar o valor de chave do elemento, use crIter->first, que é equivalente a (*crIter).first. Para acessar o valor dos dados mapeados do elemento, use crIter->second, que é equivalente a (*crIter).first.

Exemplo

Veja o exemplo de rend que demonstra como declarar e usar o const_reverse_iterator.

hash_map::count

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna o número de elementos em um hash_map cuja chave corresponde a uma chave especificada pelo parâmetro.

size_type count(const Key& key) const;

Parâmetros

key
O valor de chave dos elementos a serem correspondidos a partir de hash_map.

Valor de retorno

1, se o hash_map tiver um elemento cuja chave de classificação corresponde à chave de parâmetro; 0, se o hash_map não tiver um elemento com uma chave correspondente.

Comentários

A função membro retorna o número de elementos x no intervalo

lower_bound(key), upper_bound(key)

que será 0 ou 1, no caso de hash_map, que é um contêiner associativo exclusivo.

Exemplo

O exemplo a seguir demonstra o uso da função de membro 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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna um iterador const que trata o primeiro elemento em um hash_map invertido.

const_reverse_iterator crbegin() const;

Valor de retorno

Um iterador bidirecional invertido const que trata o primeiro elemento em um hash_map invertido ou que endereça o que foi o último elemento no hash_map não invertido.

Comentários

crbegin é usado com um hash_map invertido, assim como begin é usado com um hash_map.

Com o valor retornado crbegin, o objeto hash_map não pode ser modificado.

crbegin pode ser usado para iterar em um hash_map no sentido inverso.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna um iterador const que trata o local após o último elemento em um hash_map invertido.

const_reverse_iterator crend() const;

Valor de retorno

Um iterador bidirecional inverso const que trata a localização que vem após o último elemento em um hash_map invertido (o local que precedeu o primeiro elemento no hash_map não invertido).

Comentários

crend é usado com um hash_map invertido, assim como hash_map::end é usado com um hash_map.

Com o valor retornado crend, o objeto hash_map não pode ser modificado.

crend pode ser usado para testar se um iterador inverso alcançou o final de sua hash_map.

O valor retornado por crend não deve ser desreferenciado.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo de inteiro com sinal que pode ser usado para representar o número de elementos de um hash_map em um intervalo entre os elementos apontado pelos iteradores.

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

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Insere um elemento construído adequadamente em um hash_map.

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

Parâmetros

val
O valor usado para construir um elemento a ser inserido no hash_map, a menos que o hash_map já contenha o elemento (ou, de modo geral, um elemento cuja chave seja ordenada de maneira equivalente).

Valor de retorno

A função membro emplace retorna um par cujo componente bool retorna true se uma inserção tiver sido feita e false se o hash_map já contivesse um elemento cuja chave tinha um valor equivalente na ordenação e cujo componente iterator retorna o endereço em que um novo elemento foi inserido ou onde o elemento já estava localizado.

Para acessar o componente iterator de um par pr retornado por essa função membro, use pr.first e, para desreferenciar, use *(pr.first). Para acessar o componente bool de um par pr retornado por essa função membro, use pr.second e, para desreferenciar, use *(pr.second).

Comentários

O hash_map::value_type de um elemento é um par, de forma que o valor de um elemento será um par ordenado com o primeiro componente igual ao valor de chave e o segundo componente igual ao valor dos dados do elemento.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Insere um elemento construído adequadamente em um hash_map, com uma dica de posicionamento.

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

Parâmetros

val
O valor usado para construir um elemento a ser inserido no hash_map, a menos que o hash_map já contenha o elemento (ou, de modo geral, um elemento cuja chave seja ordenada de maneira equivalente).

c
Uma dica relacionada ao local do qual se começa a procurar pelo ponto de inserção correto.

Valor de retorno

A função de membro hash_multimap::emplace retorna um iterador que aponta para a posição em que o novo elemento foi inserido no hash_map ou em que o elemento existente com uma ordenação equivalente está localizado.

Comentários

O hash_map::value_type de um elemento é um par, de forma que o valor de um elemento será um par ordenado com o primeiro componente igual ao valor de chave e o segundo componente igual ao valor dos dados do elemento.

A inserção poderá ocorrer em um tempo constante amortizado, em vez de no tempo logarítmico, se o ponto de inserção seguir _Where imediatamente.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Testa se hash_map está vazio.

bool empty() const;

Valor de retorno

true se hash_map for vazio; false se hash_map não for vazio.

Comentários

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna um iterador que trata o local após o último elemento em um hash_map.

const_iterator end() const;

iterator end();

Valor de retorno

Retorna um iterador bidirecional que trata o local após o último elemento em um hash_map. Se o hash_map estiver vazio, então hash_map::end == hash_map::begin.

Comentários

end é usado para testar se um iterador atingiu o fim de seu hash_map.

O valor retornado por end não deve ser desreferenciado.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna um par de iteradores, respectivamente, para o primeiro elemento em um hash_map com uma chave que é maior do que uma chave especificada e para o primeiro elemento no hash_map com uma chave igual ou maior que a chave.

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

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

Parâmetros

key
O valor de chave do argumento a ser comparado com a chave de classificação de um elemento do hash_map que está sendo pesquisado.

Valor de retorno

Um par de iteradores em que o primeiro é o lower_bound da chave e o segundo é o upper_bound da chave.

Para acessar o primeiro iterador de um par pr retornado pela função membro, use pr.first e para desreferenciar o iterador de limite inferior, use *(pr.first). Para acessar o segundo iterador de um par pr retornado pela função membro, use pr.second e para desreferenciar o iterador de limite inferior, use *(pr.second).

Comentários

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Remove um elemento ou um intervalo de elementos em um hash_map das posições especificadas ou remove elementos que correspondem a uma chave especificada.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Parâmetros

_Where
Posição do elemento a ser removido de hash_map.

first
Posição do primeiro elemento removido de hash_map.

last
Posição além do último elemento removido de hash_map.

key
O valor de chave dos elementos a serem removidos do hash_map.

Valor de retorno

Para as duas primeiras funções membro, um iterador bidirecional que designa o primeiro elemento restante além de qualquer elemento removido ou um ponteiro para o final do hash_map, se não houver tal elemento.

Para a terceira função membro, ele retorna o número de elementos que foram removidos do hash_map.

Comentários

As funções membro nunca geram uma exceção.

Exemplo

O exemplo a seguir demonstra o uso da função de membro 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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna um iterador que trata do local de um elemento em um hash_map que tem uma chave equivalente a uma chave especificada.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parâmetros

key
O valor da chave a ser correspondido pela chave de classificação de um elemento do hash_map que está sendo pesquisado.

Valor de retorno

Um iterador que trata do local de um elemento com uma chave especificada ou do local que sucede o último elemento no hash_map se nenhuma correspondência for encontrada para a chave.

Comentários

find retorna um iterador que trata de um elemento no hash_map, cuja chave de classificação é equivalente à chave de argumento em um predicado binário que induz uma ordenação com base em uma relação de comparação do tipo "menor que".

Se o valor retornado de find for atribuído a um const_iterator, o objeto hash_map não poderá ser modificado. Se o valor retornado de find for atribuído a um iterator, o objeto hash_map poderá ser modificado

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna uma cópia do objeto alocador usado para construir o hash_map.

Allocator get_allocator() const;

Valor de retorno

O alocador usado pelo hash_map.

Comentários

Alocadores para a classe hash_map especificam como a classe gerencia o armazenamento. Os alocadores padrão fornecidos com as classes de contêiner da Biblioteca Padrão C++ são suficientes para a maioria das necessidades de programação. Gravando e usando sua própria classe de alocador é um tópico avançado do C++.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Constrói um hash_map que está vazio ou que é uma cópia de todo ou parte de algum outro 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
A classe do alocador de armazenamento a ser usado para este objeto hash_map, cujo padrão é Allocator.

Comp
A função de comparação do tipo const Traits usada para ordenar os elementos no hash_map, cujo padrão é hash_compare.

Right
O hash_map do qual o mapa construído é uma cópia.

First
A posição do primeiro elemento no intervalo de elementos a serem copiados.

Last
A posição do primeiro elemento além do intervalo de elementos a serem copiados.

IList
O initializer_list

Comentários

Todos os construtores armazenam um tipo de objeto de alocador que gerencia o armazenamento de memória para a hash_map e que, posteriormente, pode ser retornado ao chamar get_allocator. O parâmetro do alocador muitas vezes é omitido nas declarações de classe e nas macros de pré-processamento usadas para substituir os alocadores alternativos.

Todos os construtores inicializam seu hash_map.

Todos os construtores armazenam um objeto de função do tipo Traits, que é usado para estabelecer uma ordem entre as chaves da hash_map e que posteriormente pode ser retornado ao chamar key_comp.

Os primeiros três construtores especificam um hash_map inicial vazio, o segundo especifica o tipo de função de comparação (Comp) a ser usada para estabelecer a ordem dos elementos e o terceiro especifica explicitamente o tipo de alocador (Al) a ser usado. A palavra-chave explicit suprime determinados tipos de conversão de tipo automática.

O quarto construtor especifica uma cópia do hash_map Right.

Os próximos três construtores copiam o intervalo [First, Last) de um hash_map com clareza crescente para especificar o tipo de função de comparação da classe Traits e do alocador.

O último construtor move o hash_map Right.

hash_map::insert

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Insere um elemento ou um intervalo de elementos em um 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
O valor de um elemento a ser inserido no hash_map, a menos que o hash_map já contenha o elemento ou, de modo geral (um elemento cuja chave seja ordenada de maneira equivalente).

_Where
Uma dica relacionada ao local do qual se começa a procurar pelo ponto de inserção correto.

first
A posição do primeiro elemento a ser copiado de um hash_map.

last
A posição logo após o último elemento a ser copiado de um hash_map.

Valor de retorno

A primeira função membro insert retorna um par cujo componente bool retorna true se uma inserção tiver sido feita e false se o hash_map já contivesse um elemento cuja chave tinha um valor equivalente na ordenação e cujo componente do iterador retorna o endereço em que um novo elemento foi inserido ou onde o elemento já estava localizado.

Para acessar o componente do iterador de um par pr retornado por essa função membro, use pr.first e, para desreferenciar, use (pr.first). Para acessar o componente bool de um par pr retornado por essa função membro, use pr.second e, para desreferenciar, use \(pr.second).

A segunda função membro insert, a versão de dica, retorna um iterador que aponta para a posição em que o novo elemento foi inserido no hash_map.

As duas últimas funções de membro insert se comportam da mesma forma que as duas primeiras, mas elas constroem o valor inserido.

Comentários

O value_type de um elemento é um par, de forma que o valor de um elemento será um par ordenado com o primeiro componente igual ao valor de chave e o segundo componente igual ao valor dos dados do elemento.

A inserção poderá ocorrer em um tempo constante amortizado para a versão de dica da inserção, em vez de no tempo logarítmico, se o ponto de inserção seguir _Where imediatamente.

A terceira função membro insere a sequência de valores de elemento em um hash_map que corresponde a cada elemento tratado por um iterador no intervalo *[First, Last)* de um conjunto especificado.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo que fornece um iterador bidirecional que pode ler ou modificar qualquer elemento em um hash_map.

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

Comentários

O iterator definido por hash_map aponta para elementos que são objetos de value_type, que são do tipo pair<const Key, Type>, cujo primeiro membro é a chave para o elemento e o segundo membro é a referência mapeada mantida pelo elemento.

Para desreferenciar um iterador nomeado Iter que aponta para um elemento em um multimap, use o operador ->.

Para acessar o valor de chave do elemento, use Iter->first, que é equivalente a (*Iter).first. Para acessar o valor dos dados mapeados do elemento, use Iter->second, que é equivalente a (*Iter).second.

Um tipo de iterator pode ser usado para modificar o valor de um elemento.

Exemplo

Confira begin, para ver um exemplo de como declarar e usar o iterator.

hash_map::key_comp

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Recupera uma cópia do objeto de comparação usada para ordenar chaves em um hash_map.

key_compare key_comp() const;

Valor de retorno

Retorna o objeto de função que um hash_map usa para ordenar os seus elementos.

Comentários

O objeto armazenado define a função membro

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

que retorna true se left for precedente e não igual a right na ordem de classificação.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo que fornece um objeto de função que pode comparar duas chaves de classificação para determinar a ordem relativa de dois elementos no mapa.

typedef Traits key_compare;

Comentários

key_compare é um sinônimo do parâmetro de modelo Traits.

Para obter mais informações sobre Traits, confira o tópico hash_map Classe.

Exemplo

Confira key_comp, para ver um exemplo de como declarar e usar key_compare.

hash_map::key_type

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo que descreve o objeto de chave de classificação que constitui cada elemento do hash_map.

typedef Key key_type;

Comentários

key_type é um sinônimo do parâmetro de modelo Key.

Para obter mais informações sobre Key, consulte a seção Comentários do tópico hash_mapClasse .

Exemplo

Confira value_type, para ver um exemplo de como declarar e usar key_type.

hash_map::lower_bound

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna um iterador para o primeiro elemento em um hash_map com um valor de chave que é igual ou maior que uma chave especificada.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parâmetros

key
O valor de chave do argumento a ser comparado com a chave de classificação de um elemento do hash_map que está sendo pesquisado.

Valor de retorno

Um iterator ou const_iterator que tratará a localização de um elemento em uma hash_mapcom uma chave, que é igual ou maior que a chave de argumento ou que tratará o local após o último elemento na hash_map se nenhuma correspondência for encontrada para a chave.

Se o valor retornado de lower_bound for atribuído a um const_iterator, o objeto hash_map não poderá ser modificado. Se o valor retornado de lower_bound for atribuído a um iterator, o objeto hash_map poderá ser modificado.

Comentários

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo que representa o tipo de dados armazenado em um hash_map.

typedef Type mapped_type;

Comentários

O tipo mapped_type é um sinônimo do parâmetro do modelo Type.

Para obter mais informações sobre Type, confira o tópico hash_map Classe.

Exemplo

Confira value_type, para ver um exemplo de como declarar e usar key_type.

hash_map::max_size

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna o comprimento máximo do hash_map.

size_type max_size() const;

Valor de retorno

O comprimento máximo possível da hash_map.

Comentários

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Insere um elemento em um hash_map com um valor de chave especificado.

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

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

Parâmetros

key
O valor de chave do elemento a ser inserido.

Valor de retorno

Uma referência ao valor de dados do elemento inserido.

Comentários

Se o valor da chave do argumento não for encontrado, ele será inserido junto com o valor padrão do tipo de dados.

operator[] pode ser usado para inserir elementos em um hash_map m usando

m[ key] = DataValue;

em que DataValue é o valor de mapped_type do elemento com um valor de chave de key.

Ao usar operator[] para inserir elementos, a referência retornada não indica se uma inserção está alterando um elemento preexistente ou criando um novo. As funções membro find e insert podem ser usadas para determinar se um elemento com uma chave especificada já está presente antes de uma inserção.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Substitui os elementos do hash_map por uma cópia de outro hash_map.

hash_map& operator=(const hash_map& right);

hash_map& operator=(hash_map&& right);

Parâmetros

right
A classe right que está sendo copiado no hash_map.

Comentários

Após apagar os elementos existentes em um hash_map, operator= copiará ou moverá o conteúdo de right para hash_map.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo que fornece um ponteiro para um elemento em um hash_map.

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

Comentários

Um tipo de pointer pode ser usado para modificar o valor de um elemento.

Na maioria dos casos, um iterator deve ser usado para acessar os elementos em um objeto hash_map.

hash_map::rbegin

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna um iterador que trata o primeiro elemento em um hash_map invertido.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor de retorno

Um iterador bidirecional constante invertido que aborda o primeiro elemento em uma hash_map invertida ou abordando o que foi o último elemento na hash_map não invertida.

Comentários

rbegin é usado com um hash_map invertido, assim como begin é usado com um hash_map.

Se o valor retornado de rbegin for atribuído a uma const_reverse_iterator, o objeto hash_map não poderá ser modificado. Se o valor retornado de rbegin for atribuído a uma reverse_iterator, o objeto hash_map não poderá ser modificado.

rbegin pode ser usado para iterar em um hash_map no sentido inverso.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo que fornece uma referência a um elemento armazenado em um hash_map.

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

Comentários

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna um iterador que trata o local após o último elemento em um hash_map invertido.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valor de retorno

Um iterador bidirecional inverso que aborda a localização que vem após o último elemento em uma hash_map invertida (o local que precedeu o primeiro elemento no hash_map não invertido).

Comentários

rend é usado com um hash_map invertido, assim como end é usado com um hash_map.

Se o valor retornado de rend for atribuído a uma const_reverse_iterator, o objeto hash_map não poderá ser modificado. Se o valor retornado de rend for atribuído a uma reverse_iterator, o objeto hash_map não poderá ser modificado.

rend pode ser usado para testar se um iterador inverso alcançou o final de sua hash_map.

O valor retornado por rend não deve ser desreferenciado.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo que fornece um iterador bidirecional que pode ler ou modificar um elemento em um hash_map invertido.

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

Comentários

Um tipo reverse_iterator não pode modificar o valor de um elemento e é usado para iterar o hash_map invertido.

O reverse_iterator definido por hash_map aponta para elementos que são objetos de value_type, que são do tipo pair<const Key, Type>, cujo primeiro membro é a chave para o elemento e o segundo membro é a referência mapeada mantida pelo elemento.

Para desreferenciar um reverse_iterator rIter apontamento para um elemento em um hash_map, use o -> operador.

Para acessar o valor de chave do elemento, use rIter->first, que é equivalente a (*rIter).first. Para acessar o valor dos dados mapeados do elemento, use rIter->second, que é equivalente a (*rIter).first.

Exemplo

Confira rbegin, para ver um exemplo de como declarar e usar reverse_iterator.

hash_map::size

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna o número de elementos no hash_map.

size_type size() const;

Valor de retorno

O comprimento atual do hash_map.

Comentários

Exemplo

O exemplo a seguir demonstra o uso da função de membro 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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo de inteiro sem sinal que pode representar o número de elementos em um hash_map.

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

Comentários

Exemplo

Confira size, para ver um exemplo de como declarar e usar size_type

hash_map::swap

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Troca os elementos de dois hash_maps.

void swap(hash_map& right);

Parâmetros

right
O argumento hash_map que fornece os elementos a serem trocados com o destino hash_map.

Comentários

A função membro não invalida nenhuma referência, ponteiro ou iterador que designa elementos nos dois hash_maps cujos elementos estão sendo trocados.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna um iterador para o primeiro elemento em um hash_map com uma chave cujo valor é maior que aquele de uma chave especificada.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parâmetros

key
O valor de chave do argumento a ser comparado com o valor da chave de classificação de um elemento do hash_map que está sendo pesquisado.

Valor de retorno

Um iterator ou const_iterator que tratará a localização de um elemento em um hash_map com uma chave, que é maior que a chave de argumento ou que tratará o local após o último elemento no hash_map se nenhuma correspondência for encontrada para a chave.

Se o valor retornado for atribuído a um const_iterator, o objeto hash_map não pode ser modificado. Se o valor retornado de for atribuído a iterator, o objeto hash_map poderá ser modificado.

Comentários

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Retorna um objeto de função que determina a ordem dos elementos em um hash_map comparando os valores de chave.

value_compare value_comp() const;

Valor de retorno

Retorna o objeto da função de comparação que um hash_map usa para ordenar os seus elementos.

Comentários

Para um hash_map m, se dois elementos e1 (k1, d1) e e2 (k2, d2) são objetos do tipo value_type, onde k1 e k2 são suas chaves do tipo key_type e d1 e são d2 seus dados do tipo mapped_type, então m.value_comp()(e1, e2) é equivalente a m.key_comp()(k1, k2). Um objeto armazenado define a função de membro

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

que retornará true se o valor de chave left for precedente e for diferente do valor de chave de right na ordem de classificação.

Exemplo

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

Observação

Esta API está obsoleta. A alternativa é chamar a classe unordered_map.

Um tipo que representa o tipo do objeto armazenado em um hash_map.

typedef pair<const Key, Type> value_type;

Comentários

value_type é declarado como pair<const key_type, mapped_type> e não como pair<key_type, mapped_type> porque as chaves de um contêiner associativo não podem ser alteradas usando uma referência ou iterador não constante.

Exemplo

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

Confira também

Acesso Thread-Safe na Biblioteca Padrão C++
Referência da biblioteca padrão C++