Classe hash_multimap

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

Parâmetros

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

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

Traços
O tipo que inclui dois objetos de função, um de classe Traits que é capaz de comparar dois valores de elemento como chaves de classificação para determinar sua ordem relativa e uma função 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 o é o hash_compare<Key, less<Key>> valor padrão.

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

Observações

O hash_multimap é:

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

• Múltiplo, porque seus elementos não precisam ter chaves exclusivas, de modo que um valor de chave pode ter muitos valores de dados de elemento associados a ele.

• Um contêiner associativo de par, porque seus valores 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_multimap, 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_multimap deve ser o recipiente associativo de escolha quando as condições que associam os valores às suas chaves são satisfeitas pela aplicação. Um modelo para este tipo de estrutura é uma lista ordenada de palavras-chave com valores de cadeia de caracteres associados fornecendo, digamos, definições, onde as palavras nem sempre foram definidas de forma exclusiva. Se, em vez disso, as palavras-chave fossem definidas exclusivamente para que as chaves fossem únicas, então um hash_map 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 um hash_multiset seria a estrutura de contêiner apropriada.

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

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 um hash_multimap é 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 classe hash_multimap é um iterador bidirecional, mas as funções de membro da classe inserem e hash_multimap têm 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 aqueles 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 hash_multimap 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 hash_multimap mínimo de funcionalidade, mas é suficiente para ser capaz de falar significativamente sobre uma gama de iteradores [First, Last) no contexto das funções de membro.

Construtores

Typedefs (definições de tipos)

Funções de membro

Operadores

Requerimentos

Cabeçalho:<hash_map>

Espaço de nomes: stdext

hash_multimap::allocator_type

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

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

Observações

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

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

Exemplo

Veja o exemplo para get_allocator para um exemplo usando allocator_type.

hash_multimap::começar

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

const_iterator begin() const;

iterator begin();

Valor de retorno

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

Observações

Se o valor de retorno de begin for atribuído a um const_iterator, os elementos no objeto hash_multimap não poderão ser modificados. Se o valor de retorno 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 endereçando o primeiro elemento no hash_multimap.

const_iterator cbegin() const;

Valor de retorno

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

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 aborda o local que sucede o último elemento em um hash_multimap.

const_iterator cend() const;

Valor de retorno

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

Observações

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

Exemplo

O exemplo a seguir demonstra o uso da função de 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 const elemento no hash_multimap.

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_multimap aponta para objetos de value_type, que são do tipo pair<const Key, Type>. O valor da chave está disponível através do primeiro par de membros, e o valor do elemento mapeado está disponível através do segundo membro do par.

Para cancelar a referência de um const_iteratorcIter elemento apontando para um elemento em um hash_multimap, 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 o exemplo para começar para obter um exemplo usando const_iterator.

hash_multimap::const_pointer

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

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

hash_multimap::const_reference

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

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

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 const elemento no hash_multimap.

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_multimap em sentido inverso.

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 para o elemento e cujo segundo membro é o dado mapeado mantido pelo elemento.

Para cancelar a referência de um const_reverse_iteratorcrIter elemento apontando para um elemento em um hash_multimap, 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).second.

Exemplo

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

hash_multimap::contagem

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

size_type count(const Key& key) const;

Parâmetros

chave
A chave dos elementos a combinar a partir do hash_multimap.

Valor de retorno

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

Observações

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

[lower_bound (key), upper_bound (key) )

que têm uma chave de valor de chave.

Exemplo

O exemplo a seguir demonstra o uso da função de 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 endereçando o primeiro elemento em um hash_multimap invertido.

const_reverse_iterator crbegin() const;

Valor de retorno

Um iterador bidirecional reverso const abordando o primeiro elemento em um hash_multimap reverso ou abordando o que havia sido o último elemento no não reverso hash_multimap.

Observações

crbegin é usado com uma hash_multimap invertida, assim como hash_multimap::begin é usado com um hash_multimaparquivo .

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

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

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 aborda o local que sucede o último elemento em um hash_multimap invertido.

const_reverse_iterator crend() const;

Valor de retorno

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

Observações

crend é usado com uma hash_multimap invertida, assim como hash_multimap::end é usado com uma hash_multimap.

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

crend pode ser usado para testar se um iterador reverso atingiu o final de sua 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 ifference_type

Um tipo de inteiro assinado que pode ser usado para representar o número de elementos de um hash_multimap em um intervalo entre elementos apontados por iteradores.

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

Observações

O difference_type é o tipo retornado ao subtrair ou incrementar através de iteradores do contêiner. O difference_type é normalmente usado para representar o número de elementos no intervalo [ primeiro, último) entre os iteradores first e last, inclui o elemento apontado por first e o intervalo de elementos até, mas não incluindo, o elemento apontado por last.

Observe que, embora difference_type esteja disponível para todos os iteradores que satisfaçam os requisitos de um iterador de entrada, que inclui a classe de iteradores bidirecionais suportados por contêineres reversíveis, como set, a subtração entre iteradores só é suportada por 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 no lugar em um hash_multimap.

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

Parâmetros

Val
O valor usado para mover constrói um elemento a ser inserido no hash_multimap.

Valor de retorno

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

Observações

O hash_multimap::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_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 no lugar em uma 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 mover constrói um elemento a ser inserido no hash_multimap a menos que o hash_multimap 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.

Valor de retorno

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

Observações

O hash_multimap::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 seguir imediatamente _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.

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 aborda o local que sucede o último elemento em um hash_multimap.

const_iterator end() const;

iterator end();

Valor de retorno

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

Observações

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

chave
A chave de 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 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. primeiro e para desreferenciar o iterador de limite inferior, use *(pr. primeiro). Para acessar o segundo iterador de um par pr retornado pela função de membro, use pr. segundo e para desreferenciar o iterador de limite superior, use *(pr. segundo).

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 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 remover do hash_multimap.

primeira
Posição do primeiro elemento retirado do hash_multimap.

último
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 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_multimap se tal elemento não existir.

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

Observações

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

Exemplo

O exemplo a seguir demonstra o uso da função de 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 endereçando 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 aborda o primeiro local de um elemento com uma chave especificada ou o local que sucede o último elemento no hash_multimap se nenhuma correspondência for encontrada para a chave.

Observações

A função de membro retorna um iterador que aborda um elemento no hash_multimap cuja chave de classificação é equivalent para a 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_multimap não poderá ser modificado. Se o valor de retorno 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.

Observações

Os alocadores para a classe hash_multimap 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_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

Constrói um hash_multimap que está vazio ou é uma cópia de todo ou 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 usada para esse objeto 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.

Direito
O mapa do qual o conjunto construído deve ser uma cópia.

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

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

IList
O initializer_list copiar.

Observações

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

Todos os construtores inicializam seus hash_multimap.

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 pode ser retornado posteriormente chamando key_comp.

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

Os próximos três construtores copiam o intervalo First, Last) de um mapa com crescente explicitação na especificação do tipo de função de comparação de classe Traits e 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 esse elemento ou, mais geralmente, a menos que já contenha um elemento cuja chave esteja ordenada de forma equivalente.

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

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

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

Valor de retorno

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

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

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

As duas insert últimas funções de membro se comportam da mesma forma que as duas primeiras, exceto que elas movem-constroem 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 no qual 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 insert, em vez de tempo logarítmico, se o ponto de inserção seguir imediatamente Where.

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;

Observações

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 dado mapeado mantido pelo elemento.

Para cancelar a referência de um iterador chamado Iter que aponta para um elemento em um hash_multimap, 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).first.

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

Exemplo

Veja o exemplo para começar 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.

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_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;

Observações

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

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

Exemplo

Veja o exemplo para key_comp para um exemplo de 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;

Observações

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

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

Exemplo

Veja o exemplo para value_type para obter um exemplo de como declarar e usar key_compareo .

hash_multimap::lower_bound

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

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parâmetros

chave
A chave de 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 aborda o local de um elemento em um hash_multimap com uma chave igual ou maior que a chave de argumento, ou que aborda o local que sucede o último elemento no hash_multimap 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_multimap não poderá ser modificado. Se o valor de retorno de lower_bound for atribuído a um iterator, o objeto hash_multimap poderá ser modificado.

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 armazenados em um hash_multimap.

typedef Type mapped_type;

Observações

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

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

Exemplo

Veja o exemplo para value_type para obter um exemplo de como declarar e usar key_typeo .

hash_multimap::max_size

Devolve o comprimento máximo do hash_multimap.

size_type max_size() const;

Valor de retorno

O comprimento máximo possível do hash_multimap.

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::operador=

Substitui os elementos do 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

direito
O hash_multimap sendo copiado para o hash_multimap.

Observações

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

Observações

Um tipo 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 endereçando o primeiro elemento em um hash_multimap invertido.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor de retorno

Um iterador bidirecional reverso abordando o primeiro elemento em uma hash_multimap invertida ou abordando o que havia sido o último elemento na hash_multimap não invertida.

Observações

rbegin é usado com uma hash_multimap invertida, assim como begin é usado com uma hash_multimap.

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

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

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;

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 aborda o local que sucede o último elemento em um hash_multimap invertido.

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 hash_multimap reverso (o local que precedeu o primeiro elemento no hash_multimap não invertido).

Observações

rend é usado com uma hash_multimap invertida, assim como a extremidade é usada com uma hash_multimap.

Se o valor de retorno de rend for atribuído a um const_reverse_iterator, o objeto hash_multimap não poderá ser modificado. Se o valor de retorno 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 reverso atingiu o final de sua 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;

Observações

Um tipo reverse_iterator é usado para iterar através do hash_multimap em sentido inverso.

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

Exemplo

Veja o exemplo de rbegin para obter um exemplo de 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 comprimento atual do hash_multimap.

Exemplo

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

Exemplo

Veja o exemplo de tamanho para um exemplo de como declarar e usar size_type

hash_multimap::swap

Troca os elementos de dois hash_multimaps.

void swap(hash_multimap& right);

Parâmetros

direito
O hash_multimap fornecer os elementos a serem trocados ou o hash_multimap cujos elementos devem ser trocados com os do hash_multimap.

Observações

A função de membro não invalida referências, ponteiros ou iteradores que designam elementos nos dois hash_multimaps cujos elementos estão sendo 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_multimap com uma chave que é maior do que uma chave especificada.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parâmetros

chave
A chave de 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 aborda o local de um elemento em um hash_multimap com uma chave maior que a chave de argumento, ou que aborda o local que sucede o último elemento no hash_multimap se nenhuma correspondência for encontrada para a chave.

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

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 member retorna um objeto de função que determina a ordem dos elementos em um hash_multimap 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_multimap usa para ordenar seus elementos.

Observações

Para um hash_multimap m, se dois elementos e1 (k1, d1) e e2(k2, d2) são objetos do tipo value_type, onde k1 e k2 são suas chaves do tipo key_type e d1 e 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_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 de objeto armazenado em um hash_multimap.

typedef pair<const Key, Type> value_type;

Observações

value_type é declarado como par<const key_type, mapped_type> e não par<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_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.

Ver também

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