hash_map Classe

Armazena e recupera dados rapidamente de uma coleção na qual cada elemento é um par que tem uma chave de classificação cujo valor é exclusivo e 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 de 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 de comparação de classe capaz de 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 mapeando valores de chave dos elementos para inteiros não assinados do tipo size_t. Esse argumento é opcional e hash_compare<Key, less<Key>> é o valor padrão.

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

Observações

O hash_map é:

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

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

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

• Único no sentido de que cada um dos seus elementos deve ter uma chave única.

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

• Um modelo de classe, porque a funcionalidade que ele fornece é genérica e, portanto, independente do tipo específico de dados contidos como elementos ou chaves. Os tipos de dados a serem usados para elementos e chaves são, em vez disso, especificados como parâmetros no modelo de classe, juntamente com a função de comparação e o alocador.

A principal vantagem do hashing sobre a classificação é maior eficiência; Um hashing bem-sucedido executa inserções, exclusões e encontra em tempo médio constante 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 a elementos antigos devem ser excluídos e novos valores de chave associados a novos elementos devem ser inseridos.

A escolha do tipo de contentor deve basear-se, em geral, no tipo de pesquisa e inserção exigido pela aplicação. Os contentores associativos Hashed são otimizados para as operações de pesquisa, inserção e remoção. As funções de membro que suportam explicitamente essas operações são eficientes quando usadas com uma função hash bem projetada, 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 projetada produz uma distribuição uniforme de valores hashed e minimiza o número de colisões, onde uma colisão ocorre quando valores de chave distintos são mapeados no mesmo valor hash. Na pior das hipóteses, com a pior função hash possível, o número de operações é proporcional ao número de elementos na sequência (tempo linear).

O hash_map deve ser o recipiente associativo de escolha quando as condições que associam os valores com suas chaves são satisfeitas pelo aplicativo. Um modelo para este tipo de estrutura é uma lista ordenada de palavras-chave que ocorrem exclusivamente com valores de cadeia de caracteres associados fornecendo, digamos, definições. Se, em vez disso, as palavras tivessem mais de uma definição correta, de modo que as chaves não fossem únicas, então um hash_multimap seria o recipiente de escolha. Se, por outro lado, apenas a lista de palavras estivesse sendo armazenada, então um hash_set seria o recipiente correto. Se várias ocorrências das palavras fossem permitidas, então a hash_multiset seria a estrutura de contêiner apropriada.

O hash_map ordena a sequência que ele controla chamando um objeto hash Traits armazenado da classe value_compare. Este objeto armazenado pode ser acessado chamando a função key_compde membro. Tal objeto de função deve se comportar da mesma forma que um objeto de classe hash_compare<Key, less<Key>>. Especificamente, para todos os valores 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.

Em geral, os elementos precisam ser apenas menos do que comparáveis para estabelecer essa ordem: de modo que, dados quaisquer dois elementos, pode-se determinar que eles são equivalentes (no sentido de que nenhum é menor que o outro) ou que um é menor que o outro. Isso resulta em uma ordenação entre os elementos não equivalentes. Em uma nota mais técnica, a função de comparação é um predicado binário que induz uma ordenação fraca estrita no sentido matemático padrão. Um predicado binário f(x y) é um objeto de função que tem dois objetos x argument e y um valor de retorno de true ou false. Uma ordenação imposta a a hash_map é uma ordenação fraca estrita se o predicado binário é irreflexivo, antisimétrico e transitivo e se a equivalência é transitiva, onde dois objetos x e y são definidos como equivalentes quando f(x, y) e f(y, x) são false. Se a condição mais forte de igualdade entre chaves substitui a de equivalência, então a ordenação torna-se total (no sentido de que todos os elementos são ordenados uns em relação aos outros) e as chaves combinadas serão indiscerníveis umas das outras.

A ordem real dos elementos na sequência controlada depende da função hash, da função de ordenação e do tamanho atual da tabela de hash armazenada no objeto container. Não é possível determinar o tamanho atual da tabela de hash, portanto, em geral, não é possível prever a ordem dos elementos na sequência controlada. A inserção de elementos não invalida nenhum iterador e a remoção de elementos invalida apenas os iteradores que apontaram especificamente para os elementos removidos.

O iterador fornecido pela hash_map classe é um iterador bidirecional, mas o membro da classe funciona insert e hash_map tem versões que tomam como parâmetros de modelo um iterador de entrada mais fraco, cujos requisitos de funcionalidade são mais mínimos do que os garantidos pela classe de iteradores bidirecionais. Os diferentes conceitos de iterador 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 trabalham com eles devem limitar suas suposições aos requisitos fornecidos por esse tipo de iterador. Pode-se supor que um iterador de entrada pode ser desreferenciado para se referir a algum objeto e que ele pode ser incrementado para o próximo iterador na sequência. Este é um conjunto mínimo de funcionalidades, mas é suficiente para ser capaz de falar significativamente sobre uma gama de iteradores [First, Last) no contexto das funções de membro da classe.

Construtores

Typedefs (definições de tipos)

Funções de membro

Operadores

Requerimentos

Cabeçalho:<hash_map>

Espaço de nomes: stdext

hash_map::allocator_type

Um tipo que representa a classe alocator para o objeto hash_map.

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

Exemplo

Veja um exemplo para get_allocator um exemplo usando allocator_type.

hash_map::at

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-chave do elemento que deve ser encontrado.

Valor de retorno

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

Observações

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

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

Retorna um iterador endereçando o primeiro elemento no hash_map.

const_iterator begin() const;

iterator begin();

Valor de retorno

Um iterador bidirecional endereçando o primeiro elemento no hash_map ou o local que sucede um vazio hash_map.

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

Retorna um iterador const endereçando o primeiro elemento no hash_map.

const_iterator cbegin() const;

Valor de retorno

Um iterador bidirecional const endereçando o primeiro elemento no hash_map ou o local sucedendo um vazio hash_map.

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

Retorna um iterador const que aborda o local que sucede o último elemento em um hash_maparquivo .

const_iterator cend() const;

Valor de retorno

Um iterador bidirecional const que aborda o local sucedendo o último elemento em um hash_maparquivo . Se o hash_map estiver vazio, então hash_map::cend == hash_map::begin.

Observações

cend é usado para testar se um iterador chegou ao final de sua 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

Apaga todos os elementos de um hash_map.

void clear();

Exemplo

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

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

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

Observações

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 , ou seja, do tipo value_type, cujo primeiro membro é a chave para o elemento e cujo segundo membro é o dado mapeado pair< const Key, Type >mantido pelo elemento.

Para cancelar a referência de um const_iteratorcIter apontamento para um elemento em um hash_map, use o -> operador .

Para acessar o valor da chave para o elemento, use cIter->first, que é equivalente a (*cIter).first. Para acessar o valor do dado mapeado para o elemento, use cIter->second, que é equivalente a (*cIter).second.

Exemplo

Veja um exemplo para begin um exemplo usando const_iterator.

hash_map::const_pointer

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

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

Observações

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

hash_map::const_reference

Um tipo que fornece uma referência a um elemento const armazenado em um hash_map para ler e executar operações const.

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

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

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

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

Observações

Um tipo const_reverse_iterator não pode modificar o valor de um elemento e é usado para iterar através do hash_map inversamente.

O const_reverse_iterator definido por hash_map aponta para elementos que são objetos de , ou seja, do tipo value_type, cujo primeiro membro é a chave para o elemento e cujo segundo membro é o dado mapeado pair< const Key, Type >mantido pelo elemento.

Para cancelar a referência de um const_reverse_iteratorcrIter apontamento para um elemento em um hash_map, use o -> operador .

Para acessar o valor da chave para o elemento, use crIter->first, que é equivalente a (*crIter).first. Para acessar o valor do dado mapeado para o elemento, use crIter->second, que é equivalente a (*crIter).first.

Exemplo

Veja o exemplo para rend obter um exemplo de como declarar e usar o const_reverse_iterator.

hash_map::count

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

size_type count(const Key& key) const;

Parâmetros

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

Valor de retorno

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

Observações

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

lower_bound(key), upper_bound(key)

que é 0 ou 1 no caso de hash_map, que é um recipiente associativo único.

Exemplo

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

Retorna um const iterador endereçando o primeiro elemento em um arquivo hash_map.

const_reverse_iterator crbegin() const;

Valor de retorno

Um const iterador bidirecional reverso abordando o primeiro elemento em um invertido hash_map ou abordando o que havia sido o último elemento no invertido hash_map.

Observações

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

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

crbegin pode ser usado para iterar através de um hash_map para trás.

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

Retorna um iterador de const que aborda o local que sucede o último elemento em um hash_mapinvertido.

const_reverse_iterator crend() const;

Valor de retorno

Um const iterador bidirecional reverso que aborda o local que sucede o último elemento em um invertido hash_map (o local que precedeu o primeiro elemento no invertido hash_map).

Observações

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

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

crend pode ser usado para testar se um iterador reverso chegou ao 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

Um tipo de inteiro assinado que pode ser usado para representar o número de elementos de a hash_map em um intervalo entre elementos apontados por 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

Insere um elemento construído no local em um hash_maparquivo .

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

Parâmetros

val
O valor usado para mover constrói um elemento a ser inserido hash_map no a menos que o hash_map já contenha esse elemento (ou, mais geralmente, um elemento cuja chave é ordenada equivalentemente).

Valor de retorno

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

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

Observações

O hash_map::value_type de um elemento é um par, de modo que o valor de um elemento será um par ordenado com o primeiro componente igual ao valor da chave e o segundo componente igual ao valor de 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

Insere um elemento construído no lugar 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 mover constrói um elemento a ser inserido hash_map no a menos que o hash_map já contenha esse elemento (ou, mais geralmente, um elemento cuja chave é ordenada equivalentemente).

c
Uma dica sobre o local para começar a procurar o ponto correto de inserção.

Valor de retorno

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

Observações

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

A inserção pode ocorrer em tempo constante amortizado, em vez de tempo logarítmico, se o ponto de inserção se seguir _Whereimediatamente.

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

Testa se um hash_map está vazio.

bool empty() const;

Valor de retorno

true se o hash_map estiver vazio, false se o hash_map estiver vazio.

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

Retorna um iterador que aborda o local que sucede o último elemento em um hash_map.

const_iterator end() const;

iterator end();

Valor de retorno

Um iterador bidirecional que aborda o local que sucede o último elemento em um hash_maparquivo . Se o hash_map estiver vazio, então hash_map::end == hash_map::begin.

Observações

end é usado para testar se um iterador chegou ao final de sua 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

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 hash_map primeiro elemento no com uma chave que é 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 da chave de argumento a ser comparado com a chave de classificação de um elemento do que está sendo hash_map pesquisado.

Valor de retorno

Um par de iteradores tal 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 de 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 superior, use *(pr.second).

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

Remove um elemento ou um intervalo de elementos em um hash_map de 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 retirar do hash_map.

first
Posição do primeiro elemento retirado do hash_map.

last
Posição logo após o último elemento removido do hash_map.

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

Valor de retorno

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

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

Observações

As funções de membro nunca lançam uma exceção.

Exemplo

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

Retorna um iterador endereçando o 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 que está sendo hash_map pesquisado.

Valor de retorno

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

Observações

find Retorna um iterador que aborda um elemento na hash_map chave cuja classificação é equivalente à chave de argumento sob um predicado binário que induz uma ordenação baseada em uma relação de menor comparabilidade.

Se o valor de retorno de find for atribuído a um const_iterator, o objeto hash_map não poderá ser modificado. Se o valor de retorno de find for atribuído a um iterator, o hash_map objeto pode 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

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

Allocator get_allocator() const;

Valor de retorno

O alocador utilizado pelo hash_map.

Observações

Os alocadores para a classe hash_map especificam como a classe gerencia o armazenamento. Os alocadores padrão fornecidos com classes de contêiner C++ Standard Library são suficientes para a maioria das necessidades de programação. Escrever e usar sua própria classe de alocador é um tópico C++ avançado.

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

Constrói um hash_map que está vazio ou é 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 usada para esse hash_map objeto, cujo padrão é Allocator.

Comp
A função de comparação do tipo const Traits usada para ordenar os elementos no hash_map, que assume como hash_comparepadrão .

Right
O hash_map de que o mapa construído deve ser uma cópia.

First
A posição do primeiro elemento na gama de elementos a serem copiados.

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

IList
O initializer_list

Observações

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

Todos os construtores inicializam seus hash_maparquivos .

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

Os três primeiros construtores especificam uma inicial hash_mapvazia, além disso, o segundo especifica o tipo de função de comparação (Comp) a ser usado para estabelecer a ordem dos elementos e o terceiro especifica explicitamente o tipo de alocador (Al) a ser usado. A palavra-chave explicit suprime certos tipos de conversão automática de tipos.

O quarto construtor especifica uma cópia do hash_mapRight.

Os próximos três construtores copiam o intervalo [First, Last) de a hash_map com crescente explicitação na especificação do tipo de função de comparação de classe Traits e alocador.

O último construtor move o hash_mapRight.

hash_map::insert

Insere um elemento ou um intervalo de elementos em um hash_maparquivo .

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 hash_map no a menos que o hash_map já contenha esse elemento (ou, mais geralmente, um elemento cuja chave é ordenada equivalentemente).

_Where
Uma dica sobre o local para começar a procurar o ponto correto de inserção.

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

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

Valor de retorno

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

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

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

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

Observações

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

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

A função de terceiro membro insere a sequência de valores de elemento em um hash_map correspondente a cada elemento endereçado por um iterador de 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

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

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

Observações

O iterator definido por hash_map aponta para elementos que são objetos de , ou seja, do tipo value_type, cujo primeiro membro é a chave para o elemento e cujo segundo membro é o dado mapeado pair<const Key, Type>mantido pelo elemento.

Para cancelar a referência de um iterador chamado Iter apontando para um elemento em um multimapa, use o -> operador .

Para acessar o valor da chave para o elemento, use Iter->first, que é equivalente a (*Iter).first. Para acessar o valor do dado mapeado para o elemento, use Iter->second, que é equivalente a (*Iter).second.

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

Exemplo

Veja um exemplo begin de como declarar e usar o iterator.

hash_map::key_comp

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

key_compare key_comp() const;

Valor de retorno

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

Observações

O objeto armazenado define a função de membro

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

que retorna true se left precede 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

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;

Observações

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

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

Exemplo

Veja um exemplo key_comp de como declarar e usar key_compareo .

hash_map::key_type

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

typedef Key key_type;

Observações

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

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

Exemplo

Veja um exemplo value_type de como declarar e usar key_typeo .

hash_map::lower_bound

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

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parâmetros

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

Valor de retorno

Um iterator ou const_iterator que aborda o local de um elemento em um hash_map que com uma chave que é igual ou maior do que a chave de argumento, ou que aborda o local que sucede o último elemento no hash_map se nenhuma correspondência for encontrada para a chave.

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

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

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

typedef Type mapped_type;

Observações

O tipo mapped_type é um sinônimo para o parâmetro Typede modelo .

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

Exemplo

Veja um exemplo value_type de como declarar e usar key_typeo .

hash_map::max_size

Devolve o comprimento máximo da hash_map.

size_type max_size() const;

Valor de retorno

O comprimento máximo possível do hash_map.

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

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-chave do elemento a ser inserido.

Valor de retorno

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

Observações

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

operator[] pode ser utilizado para inserir elementos numa hash_map m utilização

m[ key] = DataValue;

onde DataValue é o valor do mapped_type 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 pré-existente ou criando um novo. As funções de 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=

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 right classe que está sendo copiada para o hash_map.

Observações

Depois de apagar quaisquer elementos existentes em um hash_map, operator= copia ou move o conteúdo de right para o 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

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;

Observações

Um tipo 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 hash_map objeto.

hash_map::rbegin

Retorna um iterador endereçando o primeiro elemento em um arquivo hash_map.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor de retorno

Um iterador bidirecional reverso abordando o primeiro elemento em um invertido hash_map ou abordando o que havia sido o último elemento no invertido hash_map.

Observações

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

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

rbegin pode ser usado para iterar através de um hash_map para trás.

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

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;

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

Retorna um iterador que aborda o local que sucede o último elemento em uma hash_mapinvertida.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valor de retorno

Um iterador bidirecional reverso que aborda o local que sucede o último elemento em um invertido hash_map (o local que precedeu o primeiro elemento no invertido hash_map).

Observações

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

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

rend pode ser usado para testar se um iterador reverso chegou ao 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

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

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

Observações

Um tipo reverse_iterator não pode modificar o valor de um elemento e é usado para iterar através do hash_map inversamente.

O reverse_iterator definido por hash_map aponta para elementos que são objetos de value_type, ou seja, do tipo pair<const Key, Type>, cujo primeiro membro é a chave para o elemento e cujo segundo membro é o dado mapeado mantido pelo elemento.

Para cancelar a referência de um reverse_iteratorrIter apontamento para um elemento em um hash_map, use o -> operador .

Para acessar o valor da chave para o elemento, use rIter->first, que é equivalente a (*rIter).first. Para acessar o valor do dado mapeado para o elemento, use rIter->second, que é equivalente a (*rIter).first.

Exemplo

Veja um exemplo rbegin de como declarar e usar reverse_iteratoro .

hash_map::size

Devolve o número de elementos na hash_map.

size_type size() const;

Valor de retorno

O comprimento atual do hash_map.

Exemplo

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

Um tipo inteiro não assinado que pode representar o número de elementos em um hash_maparquivo .

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

Exemplo

Veja um exemplo size de como declarar e usar size_type

hash_map::swap

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.

Observações

A função de membro não invalida referências, ponteiros ou iteradores que designam 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

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

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parâmetros

key
O valor da chave de argumento a ser comparado com o valor da chave de classificação de um elemento da hash_map pesquisa.

Valor de retorno

Um iterator ou const_iterator que aborda o local de um elemento em um hash_map que com uma chave que é maior do que a chave de argumento, ou que aborda o local que sucede o último elemento no hash_map se nenhuma correspondência for encontrada para a chave.

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

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

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

value_compare value_comp() const;

Valor de retorno

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

Observações

Para um hash_mapm, 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 de tipo key_type e d1 e d2 são 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 retorna true se o valor da chave de left precede e não é igual ao valor da chave de na ordem de right 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

Um tipo que representa o tipo de objeto armazenado em um hash_maparquivo .

typedef pair<const Key, Type> value_type;

Observações

value_type é declarado como sendo pair<const key_type, mapped_type> e não pair<key_type, mapped_type> porque as chaves de um contêiner associativo não podem ser alteradas usando um iterador ou referência 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.

Ver também

segurança de threads na biblioteca padrão C++
Referência da Biblioteca Padrão C++