Classe hash_multimap

A classe de contêiner hash_multimap é uma extensão da Biblioteca Padrão C++ e é usada para o armazenamento e a recuperação rápida de dados de uma coleção em que cada elemento é um par que tem uma chave de classificação cujo valor não precisa ser único e ser 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_multimap

Parâmetros

Chave
O tipo de dados da chave a ser armazenado no hash_multimap.

Tipo
O tipo de dados do elemento a ser armazenado no hash_multimap.

Características
O tipo que inclui dois objetos de função: um da classe Traits, 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 o 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 de memória do hash_multimap. Esse argumento é opcional e o valor padrão é allocator<pair <const Key, Type>>.

Comentários

O hash_multimap é:

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

• Múltipla, pois seus elementos não precisam ter chaves exclusivas para que um valor de chave possa ter muitos valores de dados de elemento associados a ele.

• Um contêiner de par associativo, pois seus valores 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_multimap, 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_multimap 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 com valores de cadeia de caracteres associados que fornecem, por exemplo, definições, em que as palavras nem sempre foram definidas exclusivamente. Se, em vez disso, as palavras-chave foram definidas exclusivamente para que essas chaves fossem exclusivas, um hash_multimap seria o contêiner ideal. Se, por outro lado, apenas as listas de palavras estavam sendo armazenadas, um hash_set seria o contêiner correto. Se forem permitidas várias ocorrências das palavras, um hash_multiset seria a estrutura de contêiner apropriada.

O hash_multimap ordena a sequência que controla chamando um objeto Traits de hash armazenado do tipo value_compare. Esse objeto armazenado pode ser acessado chamando a função membro key_comp. Um objeto de função deve 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.

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_multimap 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. Não é possível determinar o tamanho atual da tabela de hash, portanto, de modo geral, não é possível 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_multimap é um iterador bidirecional, mas as funções membro de classe insert e hash_multimap têm versões que usam como parâmetros de modelo um iterador de entrada mais fraco, cujos requisitos de funcionalidade são mais reduzidos do que aqueles garantidos 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 hash_multimap de requisitos e os algoritmos que funcionam com eles devem limitar suas suposições aos 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 hash_multimap mínimo de funcionalidades, 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_multimap	Constrói uma lista de um tamanho específico ou com elementos de um valor específico ou com um allocator específico ou como uma cópia de algum outro hash_multimap.

Typedefs

Nome do tipo	Descrição
allocator_type	Um tipo que representa a classe allocator para o objeto hash_multimap.
const_iterator	Um tipo que fornece um iterador bidirecional que pode ler um elemento const no hash_multimap.
const_pointer	Um tipo que fornece um ponteiro para um elemento const em um hash_multimap.
const_reference	Um tipo que fornece uma referência para um elemento const armazenado em um hash_multimap 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_multimap.
difference_type	Um tipo de inteiro com sinal que pode ser usado para representar o número de elementos de um hash_multimap 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_multimap.
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_multimap.
key_type	Um tipo que descreve o objeto de chave de classificação que constitui cada elemento do hash_multimap.
mapped_type	Um tipo que representa o tipo de dados armazenado em um hash_multimap.
pointer	Um tipo que fornece um ponteiro para um elemento em um hash_multimap.
referência	Um tipo que fornece uma referência a um elemento armazenado em um hash_multimap.
reverse_iterator	Um tipo que fornece um iterador bidirecional que pode ler ou modificar um elemento em um hash_multimap invertido.
size_type	Um tipo de inteiro sem sinal que pode representar o número de elementos em um hash_multimap.
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_multimap.

Funções de membro

Função de membro	Descrição
begin	Retorna um iterador que trata o primeiro elemento no hash_multimap.
cbegin	Retorna um iterador const que trata o primeiro elemento no hash_multimap.
cend	Retorna um iterador const que trata o local após o último elemento em um hash_multimap.
clear	Apaga todos os elementos de um hash_multimap.
count	Retorna o número de elementos em um hash_multimap cuja chave corresponde a uma chave especificada pelo parâmetro.
crbegin	Retorna um iterador const que trata o primeiro elemento em um hash_multimap invertido.
crend	Retorna um iterador const que trata o local após o último elemento em um hash_multimap invertido.
emplace	Insere um elemento construído adequadamente em um hash_multimap.
emplace_hint	Insere um elemento construído adequadamente em um hash_multimap, com uma dica de posicionamento.
empty	Testa se hash_multimap está vazio.
end	Retorna um iterador que trata o local após o último elemento em um hash_multimap.
equal_range	Retorna um iterador que trata o local após o último elemento em um hash_multimap.
erase	Remove um elemento ou um intervalo de elementos em um hash_multimap das posições especificadas
find	Retorna um iterador que trata do local de um elemento em um hash_multimap que tem uma chave equivalente a uma chave especificada.
get_allocator	Retorna uma cópia do objeto allocator usada para construir o hash_multimap.
insert	Insere um elemento ou um intervalo de elementos no hash_multimap na posição especificada.
key_comp	Recupera uma cópia do objeto de comparação usada para ordenar chaves em um hash_multimap.
lower_bound	Retorna um iterador para o primeiro elemento em um hash_multimap com um valor de chave que é igual ou maior que uma chave especificada.
max_size	Retorna o comprimento máximo do hash_multimap.
rbegin	Retorna um iterador que trata o primeiro elemento em um hash_multimap invertido.
rend	Retorna um iterador que trata o local após o último elemento em um hash_multimap invertido.
size	Especifica um novo tamanho para um hash_multimap.
troca	Troca os elementos de dois hash_multimaps.
upper_bound	Retorna um iterador para o primeiro elemento em um hash_multimap 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_multimap.

Operadores

Operador	Descrição
hash_multimap::operator=	Substitui os elementos de um hash_multimap por uma cópia de outro hash_multimap.

Requisitos

Cabeçalho:<hash_map>

Namespace: stdext

hash_multimap::allocator_type

Um tipo que representa a classe allocator do objeto hash_multimap.

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

Comentários

allocator_type é um sinônimo do parâmetro de modelo Allocator.

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

Exemplo

Consulte o exemplo para get_allocator para obter um exemplo do uso de allocator_type.

hash_multimap::começar

Retorna um iterador que trata do primeiro elemento no hash_multimap.

const_iterator begin() const;

iterator begin();

Valor de retorno

Um iterador bidirecional que trata do primeiro elemento no hash_multimap ou no local que sucede um hash_multimap vazio.

Comentários

Se o valor retornado de begin for atribuído a um const_iterator, os elementos no objeto hash_multimap não poderão ser modificados. Se o valor retornado de begin for atribuído a um iterator, os elementos no objeto hash_multimap poderão ser modificados.

Exemplo

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

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

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <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_multimap::cbegin

Retorna um iterador const que trata do primeiro elemento no hash_multimap.

const_iterator cbegin() const;

Valor de retorno

Um iterador bidirecional const que trata do primeiro elemento no hash_multimap ou do local que sucede um hash_multimap vazio.

Exemplo

// hash_multimap_cbegin.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

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

   hash_multimap <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_multimap::cend

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

const_iterator cend() const;

Valor de retorno

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

Comentários

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

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

Exemplo

// hash_multimap_cend.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

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

   hash_multimap <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_multimap::Limpar

Apaga todos os elementos de um hash_multimap.

void clear();

Comentários

Exemplo

O exemplo a seguir demonstra o uso da função membro hash_multimap::clear.

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

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<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_multimap is initially "
         << i  << "." << endl;

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

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

hash_multimap::const_iterator

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

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

Comentários

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

O const_iterator definido pelos pontos de hash_multimap para objetos de value_type, que são do tipo pair<const Key, Type>. O valor da chave está disponível por meio do primeiro par de membros e o valor do elemento mapeado está disponível por meio do segundo membro do par.

Para desreferenciar um const_iterator cIter apontamento para um elemento em um hash_multimap, 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

Consulte o exemplo para begin para obter um exemplo que usa const_iterator.

hash_multimap::const_pointer

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

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

Comentários

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

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

hash_multimap::const_reference

Um tipo que fornece uma referência para um elemento const armazenado em um hash_multimap 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_multimap_const_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap<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 first element in the hash_multimap 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 1st element in the hash_multimap is "
        << Ref2 << "." << endl;
}

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

hash_multimap::const_reverse_iterator

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

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 no hash_multimap em ordem inversa.

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

Para desreferenciar um const_reverse_iterator crIter apontamento para um elemento em um hash_multimap, 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).second.

Exemplo

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

hash_multimap::count

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

size_type count(const Key& key) const;

Parâmetros

chave
O valor dos elementos a serem correspondidos do hash_multimap.

Valor de retorno

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

Comentários

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

[lower_bound ( key ), upper_bound ( key ) )

que têm um valor de chave key.

Exemplo

O exemplo a seguir demonstra o uso da função membro hash_multimap::count.

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

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<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));

    // Elements do not need to have unique keys in hash_multimap,
    // so duplicates are allowed and counted
    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: 2.
The number of elements in hm1 with a sort key of 2 is: 2.
The number of elements in hm1 with a sort key of 3 is: 0.

hash_multimap::crbegin

Retorna um iterador const que trata do primeiro elemento em um hash_multimap invertido.

const_reverse_iterator crbegin() const;

Valor de retorno

Um iterador bidirecional invertido const que trata do primeiro elemento em um hash_multimap invertido ou que trata do que foi o último elemento do hash_multimap não invertido.

Comentários

crbegin é usado com um hash_multimap invertido, assim como hash_multimap::begin é usado com um hash_multimap.

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

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

Exemplo

// hash_multimap_crbegin.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

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

   hash_multimap <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_multimap hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The first element of the reversed hash_multimap hm1 is 3.

hash_multimap::crend

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

const_reverse_iterator crend() const;

Valor de retorno

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

Comentários

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

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

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

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

Exemplo

// hash_multimap_crend.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

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

   hash_multimap <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_multimap hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The last element of the reversed hash_multimap hm1 is 3.

hash_multimap::d tipo_de_diferenciação

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

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

Comentários

difference_type é o tipo retornado ao subtrair ou incrementar por meio de iteradores do contêiner. O difference_type é geralmente usado para representar o número de elementos no intervalo [ first, last) entre os iteradores first e last, inclui o elemento apontado por first e o intervalo de elementos até, mas sem incluir, o elemento apontado por last.

Observe que, embora difference_type esteja disponível para todos os iteradores que atendem aos requisitos de um iterador de entrada, que inclui a classe de iteradores bidirecionais com suporte pelos contêineres reversíveis, como conjunto, a subtração entre iteradores só tem suporte pelos iteradores de acesso aleatório fornecidos por um contêiner de acesso aleatório, como vetor.

Exemplo

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

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<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 will insert, because map keys
    // do not need to be unique
    hm1.insert(Int_Pair(2, 30));

    hash_multimap<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_multimap
    hash_multimap<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_multimap 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_multimap hm1 is: 4.
The keys of the mapped elements are: 1 2 2 3.
The values of the mapped elements are: 10 20 30 20.

hash_multimap::emplace

Insere um elemento construído em um hash_multimap.

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

Parâmetros

val
O valor usado para construir um elemento a ser inserido no hash_multimap.

Valor de retorno

A função membro emplace retorna um iterador que aponta para a posição em que o novo elemento foi inserido.

Comentários

O hash_multimap::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_multimap_emplace.cpp
// compile with: /EHsc
#include<hash_multimap>
#include<iostream>
#include <string>

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

    hm1.emplace(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_multimap::emplace_hint

Insere um elemento construído em um hash_multimap, 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_multimap, a menos que o hash_multimap 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.

Valor de retorno

A função membro hash_multimap::emplace retorna um iterador que aponta para a posição em que o novo elemento foi inserido no hash_multimap.

Comentários

O hash_multimap::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 vier imediatamente após _Where.

Exemplo

// hash_multimap_emplace_hint.cpp
// compile with: /EHsc
#include<hash_multimap>
#include<iostream>
#include <string>

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

    hm1.emplace(hm1.begin(), 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_multimap::vazio

Testa se um hash_multimap está vazio.

bool empty() const;

Valor de retorno

true se o hash_multimap estiver vazio; false se o hash_multimap não estiver vazio.

Comentários

Exemplo

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

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

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

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

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

The hash_multimap hm1 is not empty.
The hash_multimap hm2 is empty.

hash_multimap::fim

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

const_iterator end() const;

iterator end();

Valor de retorno

Um iterador bidirecional que trata do local após o último elemento em um hash_multimap. Se o hash_multimap estiver vazio, hash_multimap::end == hash_multimap::begin.

Comentários

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

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

Exemplo

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

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

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <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_multimap::equal_range

Retorna um par de iteradores, respectivamente, para o primeiro elemento em um hash_multimap com uma chave que é maior do que uma chave especificada e para o primeiro elemento no hash_multimap 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

chave
A chave do argumento a ser comparada com a chave de classificação de um elemento do hash_multimap 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 superior, use *( pr. second).

Comentários

Exemplo

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

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_multimap <int, int> IntMMap;
   IntMMap hm1;
   hash_multimap <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 <IntMMap::const_iterator, IntMMap::const_iterator> p1, p2;
   p1 = hm1.equal_range( 2 );

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

   cout << "The upper bound of the element with a key of 2\n"
        << "in the hash_multimap 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_multimap hm1 doesn't have an element "
           << "with a key less than 4." << endl;
   else
      cout << "The element of hash_multimap hm1 with a key >= 40 is: "
           << p1.first -> first << "." << endl;
}

The lower bound of the element with a key of 2
in the hash_multimap hm1 is: 20.
The upper bound of the element with a key of 2
in the hash_multimap 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_multimap hm1 doesn't have an element with a key less than 4.

hash_multimap::apagar

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

first
Posição do primeiro elemento removido do hash_multimap.

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

chave
A chave dos elementos a serem removidos do hash_multimap.

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_multimap, se não houver tal elemento.

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

Comentários

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

Exemplo

O exemplo a seguir demonstra o uso da função membro hash_multimap::erase.

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

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1, hm2, hm3;
    hash_multimap<int, int> :: iterator pIter, Iter1, Iter2;
    int i;
    hash_multimap<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_multimap 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_multimap 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
    hm3.insert(Int_Pair (2, 5));
    n = hm3.erase(2);

    cout << "After the element with a key of 2 is deleted,\n"
         << "the hash_multimap 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 of the"
         << endl;
    cout  << "2nd element is deleted, "
          << "the hash_multimap hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;
}

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

hash_multimap::encontrar

Retorna um iterador que trata o primeiro local de um elemento em um hash_multimap que tem uma chave equivalente a uma chave especificada.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parâmetros

chave
A chave a ser correspondida pela chave de classificação de um elemento do hash_multimap que está sendo pesquisado.

Valor de retorno

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

Comentários

A função membro retorna um iterador que trata de um elemento no hash_multimap, cuja chave de classificação é equivalent à 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_multimap não poderá ser modificado. Se o valor retornado de find for atribuído a um iterator, o objeto hash_multimap poderá ser modificado.

Exemplo

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

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<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, 20));
    hm1.insert(Int_Pair(3, 30));

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

    hm1_RcIter = hm1.find(3);
    cout << "The first element of hash_multimap hm1 with a key of 3 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_multimap hm1 doesn't have an element "
             << "with a key of 4." << endl;
    else
        cout << "The element of hash_multimap hm1 with a key of 4 is: "
             << hm1_RcIter -> second << "." << endl;

    // The element at a specific location in the hash_multimap 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 first element of hm1 with a key matching"
         << endl << "that of the last element is: "
         << hm1_RcIter -> second << "." << endl;

    // Note that the first element with a key equal to
    // the key of the last element is not the last element
    if (hm1_RcIter == --hm1.end())
        cout << "This is the last element of hash_multimap hm1."
             << endl;
    else
        cout << "This is not the last element of hash_multimap hm1."
             << endl;
}

The element of hash_multimap hm1 with a key of 2 is: 20.
The first element of hash_multimap hm1 with a key of 3 is: 20.
The hash_multimap hm1 doesn't have an element with a key of 4.
The first element of hm1 with a key matching
that of the last element is: 20.
This is not the last element of hash_multimap hm1.

hash_multimap::get_allocator

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

Allocator get_allocator() const;

Valor de retorno

O alocador usado pelo hash_multimap.

Comentários

Alocadores para a classe hash_multimap 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_multimap_get_allocator.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

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

   // The following lines declare objects
   // that use the default allocator.
   hash_multimap <int, int> hm1;
   hash_multimap <int, int> hm2;
   hash_multimap <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_multimap hm4
   // with the allocator of hash_multimap hm1.
   hash_multimap <int, int> hm4( less<int>( ), hm1_Alloc );

   hm4_Alloc = hm4.get_allocator( );

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

hash_multimap::hash_multimap

Cria um hash_multimap que está vazio ou que é uma cópia de todo ou de parte de algum outro hash_multimap.

hash_multimap();

explicit hash_multimap(
    const Compare& Comp);

hash_multimap(
    const Compare& Comp,
    const Allocator& Al);

hash_multimap(
    const hash_multimap& Right);

hash_multimap(
    hash_multimap&& Right);

hash_multimap(
    initializer_list<Type> IList);

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

hash_multimap(
    initializer_list<Type> IList,
    const Compare& Comp,
    const Allocator& Al);

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

template <class InputIterator>
hash_multimap(
    InputIterator First,
    InputIterator Last,
    const Compare& Comp);

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

Parâmetros

Al
A classe do alocador de armazenamento a ser usado neste objeto de hash_multimap, cujo padrão é Allocator.

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

Right
O mapa do qual o conjunto criado é 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
A initializer_list da qual fazer a cópia.

Comentários

Todos os construtores armazenam um tipo de objeto de alocador que gerencia o armazenamento de memória para o hash_multimap 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 seus hash_multimaps.

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

Os primeiros três construtores especificam um hash_multimap 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_multimap Right.

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

O oitavo construtor move o hash_multimap Right.

Os três construtores finais usam um initializer_list.

hash_multimap::inserir

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

iterator insert(
    const value_type& Val);

iterator insert(
    const_iterator Where,
    const value_type& Val);void insert(
    initializer_list<value_type> IList);

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

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

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

Parâmetros

Val
O valor de um elemento a ser inserido no hash_multimap, a menos que ele já contenha o elemento ou, de modo geral, a menos que ele já contenha um elemento cuja chave seja ordenada de maneira equivalente.

Onde
Uma dica de onde começar a procurar pelo ponto de inserção correto.

First
A posição do primeiro elemento a ser copiado de um mapa.

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

Valor de retorno

As duas primeiras funções membro insert retornam um iterador que aponta para a posição em que o novo elemento foi inserido.

A terceira função membro usa uma initializer_list para os elementos a serem inseridos.

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

As duas últimas funções 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.

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

hash_multimap::iterador

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

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

Comentários

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

Para desreferenciar um iterador de nome Iter, que aponta para um elemento em um hash_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).first.

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

Exemplo

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

hash_multimap::key_comp

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

key_compare key_comp() const;

Valor de retorno

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

Comentários

O objeto armazenado define a função membro

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

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

Exemplo

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

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

   hash_multimap <int, int, hash_compare<int, less<int>>> hm1;
   hash_multimap <int, int, hash_compare<int, less<int>>
      >::key_compare kc1 = hm1.key_comp( ) ;
   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.\n"
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false,\n"
           << "where kc1 is the function object of hm1.\n"
           << endl;
   }

   hash_multimap <int, int, hash_compare<int, greater<int>>> hm2;
   hash_multimap <int, int, hash_compare<int, greater<int>>
      >::key_compare kc2 = hm2.key_comp( );
   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."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false,\n"
           << "where kc2 is the function object of hm2."
           << endl;
   }
}

hash_multimap::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_multimap.

typedef Traits key_compare;

Comentários

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

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

Exemplo

Veja o exemplo de key_comp que demonstra como declarar e usar key_compare.

hash_multimap::key_type

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

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 Classe hash_multimap.

Exemplo

Consulte o exemplo para value_type para obter uma amostra de como declarar e usar key_compare.

hash_multimap::lower_bound

Retorna um iterador para o primeiro elemento em um hash_multimap com uma 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

chave
A chave do argumento a ser comparada com a chave de classificação de um elemento do hash_multimap que está sendo pesquisado.

Valor de retorno

Um iterador ou const_iterator que trata da localização de um elemento em um hash_multimap com uma chave que é maior ou igual à chave de argumento ou que trata do local que sucede o último elemento no hash_multimap, 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_multimap não poderá ser modificado. Se o valor retornado de lower_bound for atribuído a um iterator, o objeto hash_multimap poderá ser modificado.

Comentários

Exemplo

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   hash_multimap <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, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

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

   hm1_RcIter = hm1.lower_bound( 3 );
   cout << "The first element of hash_multimap hm1 with a key of 3 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_multimap hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_multimap hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_multimap 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 first element of hm1 with a key matching"
        << endl << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;

   // Note that the first element with a key equal to
   // the key of the last element is not the last element
   if ( hm1_RcIter == --hm1.end( ) )
      cout << "This is the last element of hash_multimap hm1."
           << endl;
   else
      cout << "This is not the last element of hash_multimap hm1."
           << endl;
}

The element of hash_multimap hm1 with a key of 2 is: 20.
The first element of hash_multimap hm1 with a key of 3 is: 20.
The hash_multimap hm1 doesn't have an element with a key of 4.
The first element of hm1 with a key matching
that of the last element is: 20.
This is not the last element of hash_multimap hm1.

hash_multimap::mapped_type

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

typedef Type mapped_type;

Comentários

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

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

Exemplo

Consulte o exemplo para value_type para obter uma amostra de como declarar e usar key_type.

hash_multimap::max_size

Retorna o tamanho máximo do hash_multimap.

size_type max_size() const;

Valor de retorno

O tamanho máximo possível do hash_multimap.

Comentários

Exemplo

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

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

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

hash_multimap::operator=

Substitui os elementos de hash_multimap por uma cópia de outro hash_multimap.

hash_multimap& operator=(const hash_multimap& right);

hash_multimap& operator=(hash_multimap&& right);

Parâmetros

direita
O hash_multimap que está sendo copiado para o hash_multimap.

Comentários

Após apagar os elementos existentes em um hash_multimap, operator= copiará ou moverá o conteúdo da direita para hash_multimap.

Exemplo

// hash_multimap_operator_as.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap<int, int> v1, v2, v3;
   hash_multimap<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_multimap::p ointer

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

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 iterador deve ser usado para acessar os elementos em um objeto hash_multimap.

hash_multimap::rbegin

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

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor de retorno

Um iterador bidirecional invertido que trata do primeiro elemento em um hash_multimap invertido ou que trata do que foi o último elemento do hash_multimap não invertido.

Comentários

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

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

rbegin pode ser usado para iterar em um hash_multimap no sentido reverso.

Exemplo

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

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

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <int, int> :: reverse_iterator hm1_rIter;
   hash_multimap <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_multimap hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_multimap in a forward order
   cout << "The hash_multimap 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_multimap in a reverse order
   cout << "The reversed hash_multimap is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

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

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

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

hash_multimap::referência

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

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

Comentários

Exemplo

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <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_multimap 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_multimap 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_multimap is 1.
The data value of first element in the hash_multimap is 10.
The modified data value of first element is 15.

hash_multimap::rend

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

const_reverse_iterator rend() const;

reverse_iterator rend();

Valor de retorno

Um iterador bidirecional inverso que trata do local que vem após o último elemento em um hash_multimap invertido (o local que precedeu o primeiro elemento no hash_multimap não invertido).

Comentários

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

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

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

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

Exemplo

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

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

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <int, int> :: reverse_iterator hm1_rIter;
   hash_multimap <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_multimap hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_multimap in a forward order
   cout << "The hash_multimap 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_multimap in a reverse order
   cout << "The reversed hash_multimap is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_multimap element can be erased by dereferencing 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_multimap is "
        << hm1_rIter -> first << "." << endl;
}

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

hash_multimap::reverse_iterator

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

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

Comentários

Um tipo reverse_iterator é usado para iterar pelo hash_multimap em ordem inversa.

O reverse_iterator definido pelo hash_multimap aponta para objetos de value_type, que são do tipo pair<const Key, Type>. O valor da chave está disponível por meio do primeiro par de membros e o valor do elemento mapeado está disponível por meio do segundo membro do par.

Exemplo

Veja o exemplo de rbegin que demonstra como declarar e usar reverse_iterator.

hash_multimap::tamanho

Retorna o número de elementos no hash_multimap.

size_type size() const;

Valor de retorno

O tamanho atual do hash_multimap.

Comentários

Exemplo

O exemplo a seguir demonstra o uso da função membro hash_multimap::size.

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

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

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

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

The hash_multimap length is 1.
The hash_multimap length is now 2.

hash_multimap::size_type

Um tipo inteiro sem sinal que conta o número de elementos em um hash_multimap.

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

Comentários

Exemplo

Veja o exemplo de size que demonstra como declarar e usar size_type

hash_multimap::swap

Troca os elementos de dois hash_multimaps.

void swap(hash_multimap& right);

Parâmetros

direita
O hash_multimap que fornece os elementos a serem trocados ou o hash_multimap cujos elementos deverão ser trocados pelos do hash_multimap.

Comentários

A função membro não invalida referências, ponteiros ou iteradores que designam elementos nos dois hash_multimaps cujos elementos são trocados.

Exemplo

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1, hm2, hm3;
   hash_multimap <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_multimap 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
   hm1.swap( hm2 );

   cout << "After swapping with hm2, hash_multimap 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_multimap hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;
}

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

hash_multimap::upper_bound

Retorna um iterador para o primeiro elemento em um hash_multimaps com uma chave que é maior que uma chave especificada.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parâmetros

chave
A chave do argumento a ser comparada com a chave de classificação de um elemento do hash_multimap que está sendo pesquisado.

Valor de retorno

Um iterador ou const_iterator que trata da localização de um elemento em um hash_multimap com uma chave que é maior que a chave de argumento ou que trata do local que sucede o último elemento no hash_multimap, se nenhuma correspondência for encontrada para a chave.

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

Comentários

Exemplo

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   hash_multimap <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.insert ( Int_Pair ( 3, 40 ) );

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

   hm1_RcIter = hm1.upper_bound( 2 );
   cout << "The first element of hash_multimap hm1\n"
        << "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.lower_bound( 4 );

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

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

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

hash_multimap::value_comp

A função membro retorna um objeto de função que determina a ordem dos elementos em um hash_multimap comparando os respectivos valores de chave.

value_compare value_comp() const;

Valor de retorno

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

Comentários

Para um hash_multimap m, se dois elementos e1 (k1, d1) e e2( k2, d2) forem objetos do tipo value_type, em que k1 e k2 forem suas chaves do tipo key_type e d1 e d2 forem seus dados do tipo mapped_type, então m.value_comp()(e1, e2) será 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_multimap_value_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

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

   hash_multimap <int, int, hash_compare<int, less<int>>> hm1;
   hash_multimap <int, int, hash_compare<int, less<int>>
      >::value_compare vc1 = hm1.value_comp( );
   hash_multimap <int,int>::iterator Iter1, Iter2;

   Iter1= hm1.insert ( hash_multimap <int, int> :: value_type ( 1, 10 ) );
   Iter2= hm1.insert ( hash_multimap <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *Iter1, *Iter2 ) == 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( *Iter2, *Iter1 ) == 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_multimap::value_type

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

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_multimap_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_multimap <int, int> hm1;
   hash_multimap <int, int> :: key_type key1;
   hash_multimap <int, int> :: mapped_type mapped1;
   hash_multimap <int, int> :: value_type value1;
   hash_multimap <int, int> :: iterator pIter;

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

   // Compare another way to insert objects into a hash_multimap
   hm1.insert ( cInt2Int ( 2, 20 ) );

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

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

   cout << "The data value of first element in the hash_multimap 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_multimap is 1.
The data value of first element in the hash_multimap is 10.
The keys of the mapped elements are: 1 2.
The values of the mapped elements are: 10 20.

Confira também

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