multimap Classe

A classe multimap C++ Standard Library é usada para o armazenamento e recuperação de dados de uma coleção na qual cada elemento é um par que tem um valor de dados e uma chave de classificação. O valor da chave não precisa ser exclusivo e é usado para ordenar os dados automaticamente. O valor de um elemento em um 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.

Sintaxe

template <class Key,
    class Type,
    class Traits=less <Key>,
    class Allocator=allocator <pair  <const Key, Type>>>
class multimap;

Parâmetros

Key
O tipo de dados de chave a ser armazenado no multimap.

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

Traits
O tipo que fornece um objeto de função que pode comparar dois valores de elemento como chaves de classificação para determinar sua ordem relativa no multimap. O predicado less<Key> binário é o valor padrão.

Em C++14, você pode habilitar a pesquisa heterogênea especificando o predicado std::less<> ou std::greater<> que não tem parâmetros de tipo. Para obter mais informações, consulte Pesquisa heterogênea em contêineres associativos

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

Observações

A classe multimapa C++ Standard Library é

• 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 iteradores bidirecionais para acessar seus elementos.

• Classificado, porque seus elementos são ordenados por valores-chave dentro do contêiner de acordo com uma função de comparação especificada.

• Múltiplo, porque seus elementos não precisam ter uma chave exclusiva, 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 dados de elemento são distintos de seus valores de chave.

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

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

A escolha do tipo de contentor deve basear-se, em geral, no tipo de pesquisa e inserção exigido pela aplicação. Os contêineres associativos 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, executando-as em um tempo que é, em média, proporcional ao logaritmo do número de elementos no contêiner. A inserção de elementos não invalida nenhum iterador e a remoção de elementos invalida apenas os iteradores que apontaram para os elementos removidos.

O multimap deve ser o recipiente associativo de escolha quando as condições que associam os valores com suas chaves são satisfeitas pelo aplicativo. Um modelo para este tipo de estrutura é uma lista ordenada de palavras-chave 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 mapa seria o recipiente de escolha. Se, por outro lado, apenas a lista de palavras estivesse sendo armazenada, então um conjunto seria o recipiente correto. Se várias ocorrências das palavras fossem permitidas, então a multiset seria a estrutura de contêiner apropriada.

O multimap ordena a sequência que ele controla chamando um objeto de função armazenado do tipo key_compare. Este objeto armazenado é uma função de comparação que pode ser acessada chamando a função key_compde membro. 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 f(x,y) binário é 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 conjunto é 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 ambos 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.

Em C++14, você pode habilitar a pesquisa heterogênea especificando o predicado std::less<> ou std::greater<> que não tem parâmetros de tipo. Consulte Pesquisa heterogênea em contêineres associativos para obter mais informações.

Membros

Construtores

Typedefs (definições de tipos)

Funções de membro

Requerimentos

Cabeçalho:<map>

Espaço de nomes: std

Os pares ( chave,valor) são armazenados em um multimap como objetos do tipo pair. A classe pair requer o cabeçalho <utility>, que é automaticamente incluído pelo <map>.

multimap::allocator_type

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

typedef Allocator allocator_type;

Exemplo

Veja o exemplo para get_allocator obter um exemplo usando allocator_type.

multimap::begin

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

const_iterator begin() const;

iterator begin();

Valor de retorno

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

Exemplo

// multimap_begin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: const_iterator m1_cIter;
   typedef pair <int, int> Int_Pair;

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

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

   m1_Iter = m1.begin ( );
   m1.erase ( m1_Iter );

   // The following 2 lines would err as the iterator is const
   // m1_cIter = m1.begin ( );
   // m1.erase ( m1_cIter );

   m1_cIter = m1.begin( );
   cout << "First element of m1 is now " << m1_cIter -> first << endl;
}

The first element of m1 is 0
First element of m1 is now 1

multimap::cbegin

Retorna um iterador const que aborda o primeiro elemento no intervalo.

const_iterator cbegin() const;

Valor de retorno

Um const iterador de acesso bidirecional que aponta para o primeiro elemento do intervalo, ou o local logo após o final de um intervalo vazio (para um intervalo vazio, cbegin() == cend()).

Observações

Com o valor de retorno de cbegin, os elementos no intervalo não podem ser modificados.

Você pode usar essa função de membro no lugar da função de membro begin() para garantir que o valor de retorno seja const_iterator. Normalmente, ele é usado em conjunto com a palavra-chave de dedução de tipo auto, conforme mostrado no exemplo a seguir. No exemplo, considere Container como um recipiente modificável (não const) de qualquer tipo que suporte begin() e cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

multimap::cend

Retorna um iterador const que aborda o local logo após o último elemento de um intervalo.

const_iterator cend() const;

Valor de retorno

Um const iterador de acesso bidirecional que aponta para além do final do intervalo.

Observações

cend é usado para testar se um iterador passou no final de seu intervalo.

Você pode usar essa função de membro no lugar da função de membro end() para garantir que o valor de retorno seja const_iterator. Normalmente, ele é usado em conjunto com a palavra-chave de dedução de tipo auto, conforme mostrado no exemplo a seguir. No exemplo, considere Container como um recipiente modificável (não const) de qualquer tipo que suporte end() e cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

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

multimap::clear

Apaga todos os elementos de um multimap.

void clear();

Exemplo

O exemplo a seguir demonstra o uso da função member multimap::clear .

// multimap_clear.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap<int, int> m1;
   multimap<int, int>::size_type i;
   typedef pair<int, int> Int_Pair;

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

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

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

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

multimap::const_iterator

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

typedef implementation-defined 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 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 apontamento para um elemento em um 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 begin obter um exemplo usando const_iterator.

multimap::const_pointer

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

typedef typename allocator_type::const_pointer const_pointer;

Observações

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

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

multimap::const_reference

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

typedef typename allocator_type::const_reference const_reference;

Exemplo

// multimap_const_ref.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   typedef pair <int, int> Int_Pair;

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

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

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

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

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

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

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

multimap::const_reverse_iterator

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

typedef std::reverse_iterator<const_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 multimap inversamente.

O const_reverse_iterator definido por 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_reverse_iteratorcrIter elemento apontando para um elemento em um 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).first.

Exemplo

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

multimap::contains

Verifique se há um elemento com a chave especificada no multimap.

bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;

Parâmetros

K
O tipo da chave.

key
O valor-chave do elemento a procurar.

Valor de retorno

true se o elemento for encontrado no recipiente; false o contrário.

Observações

contains() é novo no C++20. Para usá-lo, especifique a opção de compilador /std:c++20 ou posterior.

template<class K> bool contains(const K& key) const só participa na resolução de sobrecarga se key_compare for transparente. Consulte Pesquisa heterogênea em contêineres associativos para obter mais informações.

Exemplo

// Requires /std:c++20 or later
#include <map>
#include <string>
#include <iostream>
#include <functional>

int main()
{
    std::multimap<int, bool> m = {{0, false}, {1, true}};

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << m.contains(1) << '\n';
    std::cout << m.contains(2) << '\n';

    // call template function
    std::multimap<std::string, int, std::less<>> m2 = {{"ten", 10}, {"twenty", 20}, {"thirty", 30}};
    std::cout << m2.contains("ten");

    return 0;
}

true
false
true

multimap::count

Retorna o número de elementos em cujas multimap chaves correspondem a uma chave especificada por parâmetro.

size_type count(const Key& key) const;

Parâmetros

key
A chave dos elementos a serem combinados a partir do multimapa.

Valor de retorno

O número de elementos cujas chaves de classificação correspondem à chave de parâmetro; 0 se o multimapa 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 um valor keychave .

Exemplo

O exemplo a seguir demonstra o uso da função multimap::count member.

// multimap_count.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
    using namespace std;
    multimap<int, int> m1;
    multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

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

    // Elements don't need to have unique keys in multimap,
    // so duplicates are allowed and counted
    i = m1.count(1);
    cout << "The number of elements in m1 with a sort key of 1 is: "
         << i << "." << endl;

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

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

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

multimap::crbegin

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

const_reverse_iterator crbegin() const;

Valor de retorno

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

Observações

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

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

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

Exemplo

// multimap_crbegin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_crIter = m1.crbegin( );
   cout << "The first element of the reversed multimap m1 is "
        << m1_crIter -> first << "." << endl;
}

The first element of the reversed multimap m1 is 3.

multimap::crend

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

const_reverse_iterator crend() const;

Valor de retorno

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

Observações

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

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

crend pode ser usado para testar se um iterador reverso chegou ao final de sua multimap.

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

Exemplo

// multimap_crend.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_crIter = m1.crend( );
   m1_crIter--;
   cout << "The last element of the reversed multimap m1 is "
        << m1_crIter -> first << "." << endl;
}

The last element of the reversed multimap m1 is 1.

multimap::difference_type

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

typedef typename 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 [first, last) 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.

Embora difference_type esteja disponível para todos os iteradores que satisfazem 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

// multimap_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <map>
#include <algorithm>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   typedef pair <int, int> Int_Pair;

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

   // The following will insert as multimap keys are not unique
   m1.insert ( Int_Pair ( 2, 30 ) );

   multimap <int, int>::iterator m1_Iter, m1_bIter, m1_eIter;
   m1_bIter = m1.begin( );
   m1_eIter = m1.end( );

   // Count the number of elements in a multimap
   multimap <int, int>::difference_type  df_count = 0;
   m1_Iter = m1.begin( );
   while ( m1_Iter != m1_eIter )
   {
      df_count++;
      m1_Iter++;
   }

   cout << "The number of elements in the multimap m1 is: "
        << df_count << "." << endl;
}

The number of elements in the multimap m1 is: 4.

multimap::emplace

Insere um elemento construído no local (nenhuma operação de cópia ou movimentação é executada).

template <class... Args>
iterator emplace(Args&&... args);

Parâmetros

args
Os argumentos encaminhados para construir um elemento a ser inserido no multimap.

Valor de retorno

Um iterador para o elemento recém-inserido.

Observações

Nenhuma referência a elementos de contêiner é invalidada por essa função, mas ela pode invalidar todos os iteradores para o contêiner.

Se uma exceção for lançada durante a inserção, o contêiner será deixado inalterado e a exceção será relançada.

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

Exemplo

// multimap_emplace.cpp
// compile with: /EHsc
#include <map>
#include <string>
#include <iostream>

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: " << endl;

    for (const auto& p : m) {
        cout << "(" << p.first <<  "," << p.second << ") ";
    }

    cout << endl;
}

int main()
{
    multimap<string, string> m1;

    m1.emplace("Anna", "Accounting");
    m1.emplace("Bob", "Accounting");
    m1.emplace("Carmine", "Engineering");

    cout << "multimap modified, now contains ";
    print(m1);
    cout << endl;

    m1.emplace("Bob", "Engineering");

    cout << "multimap modified, now contains ";
    print(m1);
    cout << endl;
}

multimap::emplace_hint

Insere um elemento construído no local (nenhuma operação de cópia ou movimentação é executada), com uma dica de posicionamento.

template <class... Args>
iterator emplace_hint(
    const_iterator where,
    Args&&... args);

Parâmetros

args
Os argumentos encaminhados para construir um elemento a ser inserido no multimap.

where
O lugar para começar a procurar o ponto correto de inserção. (Se esse ponto preceder whereimediatamente, a inserção pode ocorrer em tempo constante amortizado em vez de tempo logarítmico.)

Valor de retorno

Um iterador para o elemento recém-inserido.

Observações

Nenhuma referência a elementos de contêiner é invalidada por essa função, mas ela pode invalidar todos os iteradores para o contêiner.

Durante a colocação, se uma exceção for lançada, o estado do contêiner não será modificado.

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

Para obter um exemplo de código, consulte map::emplace_hint.

multimap::empty

Testa se um multimap está vazio.

bool empty() const;

Valor de retorno

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

Exemplo

// multimap_empty.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1, m2;

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

   if ( m1.empty( ) )
      cout << "The multimap m1 is empty." << endl;
   else
      cout << "The multimap m1 is not empty." << endl;

   if ( m2.empty( ) )
      cout << "The multimap m2 is empty." << endl;
   else
      cout << "The multimap m2 is not empty." << endl;
}

The multimap m1 is not empty.
The multimap m2 is empty.

multimap::end

Retorna o iterador passado-a-fim.

const_iterator end() const;

iterator end();

Valor de retorno

O iterador passado-a-fim. Se o multimap estiver vazio, então multimap::end() == multimap::begin().

Observações

end é usado para testar se um iterador passou no final do seu multimap.

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

Para obter um exemplo de código, consulte multimap::find.

multimap::equal_range

Localiza o intervalo de elementos em que a chave do elemento corresponde a um valor especificado.

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

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

Parâmetros

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

Valor de retorno

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

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

Exemplo

// multimap_equal_range.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   typedef multimap <int, int, less<int> > IntMMap;
   IntMMap m1;
   multimap <int, int> :: const_iterator m1_RcIter;
   typedef pair <int, int> Int_Pair;

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

   pair <IntMMap::const_iterator, IntMMap::const_iterator> p1, p2;
   p1 = m1.equal_range( 2 );

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

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

   // Compare the upper_bound called directly
   m1_RcIter = m1.upper_bound( 2 );

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

   p2 = m1.equal_range( 4 );

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

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

multimap::erase

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

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parâmetros

Where
Posição do elemento a remover.

First
Posição do primeiro elemento a ser removido.

Last
Posicione logo após o último elemento a ser removido.

Key
A chave dos elementos a serem removidos.

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 elemento que é o final do mapa, se tal elemento não existir.

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

Observações

Para obter um exemplo de código, consulte map::erase.

multimap::find

Retorna um iterador que se refere ao primeiro local de um elemento em um multimap que tem uma chave equivalente a uma chave especificada.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parâmetros

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

Valor de retorno

Um iterador que se refere ao local de um elemento com uma chave especificada ou o local que sucede o último elemento no multimap (multimap::end()) se nenhuma correspondência for encontrada para a chave.

Observações

A função de membro retorna um iterador que se refere a um elemento na multimap chave cuja classificação é equivalente à chave de argumento sob um predicado binário que induz uma ordenação baseada em uma relação de menor comparabilidade.

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

Exemplo

// compile with: /EHsc /W4 /MTd
#include <map>
#include <iostream>
#include <vector>
#include <string>
#include <utility>  // make_pair()

using namespace std;

template <typename A, typename B> void print_elem(const pair<A, B>& p) {
    cout << "(" << p.first << ", " << p.second << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

template <typename C, class T> void findit(const C& c, T val) {
    cout << "Trying find() on value " << val << endl;
    auto result = c.find(val);
    if (result != c.end()) {
        cout << "Element found: "; print_elem(*result); cout << endl;
    } else {
        cout << "Element not found." << endl;
    }
}

int main()
{
    multimap<int, string> m1({ { 40, "Zr" }, { 45, "Rh" } });
    cout << "The starting multimap m1 is (key, value):" << endl;
    print_collection(m1);

    vector<pair<int, string>> v;
    v.push_back(make_pair(43, "Tc"));
    v.push_back(make_pair(41, "Nb"));
    v.push_back(make_pair(46, "Pd"));
    v.push_back(make_pair(42, "Mo"));
    v.push_back(make_pair(44, "Ru"));
    v.push_back(make_pair(44, "Ru")); // attempt a duplicate

    cout << "Inserting the following vector data into m1:" << endl;
    print_collection(v);

    m1.insert(v.begin(), v.end());

    cout << "The modified multimap m1 is (key, value):" << endl;
    print_collection(m1);
    cout << endl;
    findit(m1, 45);
    findit(m1, 6);
}

multimap::get_allocator

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

allocator_type get_allocator() const;

Valor de retorno

O alocador utilizado pelo multimap.

Observações

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

// multimap_get_allocator.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int>::allocator_type m1_Alloc;
   multimap <int, int>::allocator_type m2_Alloc;
   multimap <int, double>::allocator_type m3_Alloc;
   multimap <int, int>::allocator_type m4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   multimap <int, int> m1;
   multimap <int, int, allocator<int> > m2;
   multimap <int, double, allocator<double> > m3;

   m1_Alloc = m1.get_allocator( );
   m2_Alloc = m2.get_allocator( );
   m3_Alloc = m3.get_allocator( );

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

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

   // The following line creates a multimap m4
   // with the allocator of multimap m1.
   map <int, int> m4( less<int>( ), m1_Alloc );

   m4_Alloc = m4.get_allocator( );

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

multimap::insert

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

// (1) single element
pair<iterator, bool> insert(
    const value_type& Val);

// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
    ValTy&& Val);

// (3) single element with hint
iterator insert(
    const_iterator Where,
    const value_type& Val);

// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

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

// (6) initializer list
void insert(
    initializer_list<value_type>
IList);

Parâmetros

Val
O valor de um elemento a ser inserido no multimap.

Where
O lugar para começar a procurar o ponto correto de inserção. (Se esse ponto preceder Whereimediatamente, a inserção pode ocorrer em tempo constante amortizado em vez de tempo logarítmico.)

ValTy
Parâmetro de modelo que especifica o tipo de argumento que o mapa pode usar para construir um elemento de value_type, e perfect-forwards Val como um argumento.

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

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

InputIterator
Argumento de função de modelo que atende aos requisitos de um input iterador que aponta para elementos de um tipo que podem ser usados para construir value_type objetos.

IList
O initializer_list do qual copiar os elementos.

Valor de retorno

As funções de membro de inserção de elemento único, (1) e (2), retornam um iterador para a posição onde o novo elemento foi inserido no multimap.

As funções de membro single-element-with-hint, (3) e (4), retornam um iterador que aponta para a posição onde o novo elemento foi inserido no multimap.

Observações

Nenhum ponteiro ou referência é invalidado por essa função, mas pode invalidar todos os iteradores para o contêiner.

Durante a inserção de apenas um elemento, se uma exceção for lançada, o estado do contêiner não será modificado. Durante a inserção de vários elementos, se uma exceção for lançada, o contêiner será deixado em um estado não especificado, mas válido.

O value_type de um contêiner é um typedef que pertence ao contêiner e, para mapa, multimap<K, V>::value_type é pair<const K, V>. O valor de um elemento é 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 função de membro do intervalo (5) insere a sequência de valores do elemento em um multimap que corresponde a cada elemento endereçado por um iterador no intervalo [First, Last), portanto, Last não é inserida. A função end() de membro do contêiner refere-se à posição logo após o último elemento no contêiner — por exemplo, a instrução m.insert(v.begin(), v.end()); insere todos os elementos de v into m.

A função de membro da lista do inicializador (6) usa um initializer_list para copiar elementos para o mapa.

Para inserção de um elemento construído no local, ou seja, nenhuma operação de cópia ou movimentação é executada, consulte multimap::emplace e multimap::emplace_hint.

Exemplo

// multimap_insert.cpp
// compile with: /EHsc
#include <map>
#include <iostream>
#include <string>
#include <vector>
#include <utility>  // make_pair()

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: ";

    for (const auto& p : m) {
        cout << "(" << p.first << ", " << p.second << ") ";
    }

    cout << endl;
}

int main()
{
    // insert single values
    multimap<int, int> m1;
    // call insert(const value_type&) version
    m1.insert({ 1, 10 });
    // call insert(ValTy&&) version
    m1.insert(make_pair(2, 20));

    cout << "The original key and mapped values of m1 are:" << endl;
    print(m1);

    // intentionally attempt a duplicate, single element
    m1.insert(make_pair(1, 111));

    cout << "The modified key and mapped values of m1 are:" << endl;
    print(m1);

    // single element, with hint
    m1.insert(m1.end(), make_pair(3, 30));
    cout << "The modified key and mapped values of m1 are:" << endl;
    print(m1);
    cout << endl;

    // The templatized version inserting a jumbled range
    multimap<int, int> m2;
    vector<pair<int, int>> v;
    v.push_back(make_pair(43, 294));
    v.push_back(make_pair(41, 262));
    v.push_back(make_pair(45, 330));
    v.push_back(make_pair(42, 277));
    v.push_back(make_pair(44, 311));

    cout << "Inserting the following vector data into m2:" << endl;
    print(v);

    m2.insert(v.begin(), v.end());

    cout << "The modified key and mapped values of m2 are:" << endl;
    print(m2);
    cout << endl;

    // The templatized versions move-constructing elements
    multimap<int, string>  m3;
    pair<int, string> ip1(475, "blue"), ip2(510, "green");

    // single element
    m3.insert(move(ip1));
    cout << "After the first move insertion, m3 contains:" << endl;
    print(m3);

    // single element with hint
    m3.insert(m3.end(), move(ip2));
    cout << "After the second move insertion, m3 contains:" << endl;
    print(m3);
    cout << endl;

    multimap<int, int> m4;
    // Insert the elements from an initializer_list
    m4.insert({ { 4, 44 }, { 2, 22 }, { 3, 33 }, { 1, 11 }, { 5, 55 } });
    cout << "After initializer_list insertion, m4 contains:" << endl;
    print(m4);
    cout << endl;
}

multimap::iterator

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

typedef implementation-defined iterator;

Observações

O iterator definido por 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 iteratorIter apontamento para um elemento em um 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).second.

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

Exemplo

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

multimap::key_comp

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

key_compare key_comp() const;

Valor de retorno

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

Observações

O objeto armazenado define a função de membro

bool operator( const Key& x, const Key& y);

que retorna true se x preceder estritamente na ordem de y classificação.

Exemplo

// multimap_key_comp.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;

   multimap <int, int, less<int> > m1;
   multimap <int, int, less<int> >::key_compare kc1 = m1.key_comp( ) ;
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true, "
           << "where kc1 is the function object of m1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of m1."
           << endl;
   }

   multimap <int, int, greater<int> > m2;
   multimap <int, int, greater<int> >::key_compare kc2 = m2.key_comp( );
   bool result2 = kc2( 2, 3 ) ;
   if( result2 == true )
   {
      cout << "kc2( 2,3 ) returns value of true, "
           << "where kc2 is the function object of m2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of m2."
           << endl;
   }
}

kc1( 2,3 ) returns value of true, where kc1 is the function object of m1.
kc2( 2,3 ) returns value of false, where kc2 is the function object of m2.

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

typedef Traits key_compare;

Observações

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

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

Exemplo

Veja o exemplo para key_comp obter um exemplo de como declarar e usar key_compare.

multimap::key_type

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

typedef Key key_type;

Observações

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

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

Exemplo

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

multimap::lower_bound

Retorna um iterador para o primeiro elemento em um multimap que 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

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

Valor de retorno

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

Exemplo

// multimap_lower_bound.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <int, int> :: const_iterator m1_AcIter, m1_RcIter;
   typedef pair <int, int> Int_Pair;

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

   m1_RcIter = m1.lower_bound( 2 );
   cout << "The element of multimap m1 with a key of 2 is: "
        << m1_RcIter -> second << "." << endl;

   m1_RcIter = m1.lower_bound( 3 );
   cout << "The first element of multimap m1 with a key of 3 is: "
        << m1_RcIter -> second << "." << endl;

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

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

   // The element at a specific location in the multimap can be
   // found using a dereferenced iterator addressing the location
   m1_AcIter = m1.end( );
   m1_AcIter--;
   m1_RcIter = m1.lower_bound( m1_AcIter -> first );
   cout << "The first element of m1 with a key matching\n"
        << "that of the last element is: "
        << m1_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 ( m1_RcIter == --m1.end( ) )
      cout << "This is the last element of multimap m1."
           << endl;
   else
      cout << "This is not the last element of multimap m1."
           << endl;
}

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

multimap::mapped_type

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

typedef Type mapped_type;

Observações

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

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

Exemplo

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

multimap::max_size

Devolve o comprimento máximo da multimap.

size_type max_size() const;

Valor de retorno

O comprimento máximo possível do multimap.

Exemplo

// multimap_max_size.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <int, int> :: size_type i;

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

multimap::multimap

Constrói um multimap que está vazio ou que é uma cópia de todo ou parte de algum outro multimap.

multimap();

explicit multimap(
    const Traits& Comp);

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

map(
    const multimap& Right);

multimap(
    multimap&& Right);

multimap(
    initializer_list<value_type> IList);

multimap(
    initializer_list<value_type> IList,
    const Compare& Comp);

multimap(
    initializer_list<value_type> IList,
    const Compare& Comp,
    const Allocator& Al);

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

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

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

Parâmetros

Al
A classe de alocador de armazenamento a ser usada para esse objeto multimap, cujo padrão é Allocator.

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

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

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

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

IList
O initializer_list do qual copiar os elementos.

Observações

Todos os construtores armazenam um tipo de objeto alocador que gerencia o armazenamento de memória para o 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 usadas para substituir alocadores alternativos.

Todos os construtores inicializam seus multimaparquivos .

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

Os três primeiros construtores especificam uma inicial multimapvazia, o segundo especifica o tipo de função de comparação (Comp) a ser usada no estabelecimento da 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 multimapRight.

O quinto construtor especifica uma cópia do multimap a direita.

Os 6º, 7º e 8º construtores copiam os membros de um initializer_list.

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.

Exemplo

// multimap_ctor.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

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

    // Create an empty multimap m0 of key type integer
    multimap <int, int> m0;

    // Create an empty multimap m1 with the key comparison
    // function of less than, then insert 4 elements
    multimap <int, int, less<int> > m1;
    m1.insert(Int_Pair(1, 10));
    m1.insert(Int_Pair(2, 20));
    m1.insert(Int_Pair(3, 30));
    m1.insert(Int_Pair(4, 40));

    // Create an empty multimap m2 with the key comparison
    // function of greater than, then insert 2 elements
    multimap <int, int, less<int> > m2;
    m2.insert(Int_Pair(1, 10));
    m2.insert(Int_Pair(2, 20));

    // Create a multimap m3 with the
    // allocator of multimap m1
    multimap <int, int>::allocator_type m1_Alloc;
    m1_Alloc = m1.get_allocator();
    multimap <int, int> m3(less<int>(), m1_Alloc);
    m3.insert(Int_Pair(3, 30));

    // Create a copy, multimap m4, of multimap m1
    multimap <int, int> m4(m1);

    // Create a multimap m5 by copying the range m1[ first,  last)
    multimap <int, int>::const_iterator m1_bcIter, m1_ecIter;
    m1_bcIter = m1.begin();
    m1_ecIter = m1.begin();
    m1_ecIter++;
    m1_ecIter++;
    multimap <int, int> m5(m1_bcIter, m1_ecIter);

    // Create a multimap m6 by copying the range m4[ first,  last)
    // and with the allocator of multimap m2
    multimap <int, int>::allocator_type m2_Alloc;
    m2_Alloc = m2.get_allocator();
    multimap <int, int> m6(m4.begin(), ++m4.begin(), less<int>(), m2_Alloc);

    cout << "m1 =";
    for (auto i : m1)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m2 =";
    for (auto i : m2)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m3 =";
    for (auto i : m3)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m4 =";
    for (auto i : m4)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m5 =";
    for (auto i : m5)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m6 =";
    for (auto i : m6)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a multimap m8 by copying in an initializer_list
    multimap<int, int> m8{ { { 1, 1 }, { 2, 2 }, { 3, 3 }, { 4, 4 } } };
    cout << "m8: = ";
    for (auto i : m8)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a multimap m9 with an initializer_list and a comparator
    multimap<int, int> m9({ { 5, 5 }, { 6, 6 }, { 7, 7 }, { 8, 8 } }, less<int>());
    cout << "m9: = ";
    for (auto i : m9)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a multimap m10 with an initializer_list, a comparator, and an allocator
    multimap<int, int> m10({ { 9, 9 }, { 10, 10 }, { 11, 11 }, { 12, 12 } }, less<int>(), m9.get_allocator());
    cout << "m10: = ";
    for (auto i : m10)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

}

multimap::operator=

Substitui os elementos de um multimap por uma cópia de outro multimap.

multimap& operator=(const multimap& right);

multimap& operator=(multimap&& right);

Parâmetros

right
O multimap sendo copiado para o multimap.

Observações

Depois de apagar quaisquer elementos existentes em um multimap, operator= copia ou move o conteúdo de right para o multimap.

Exemplo

// multimap_operator_as.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
   {
   using namespace std;
   multimap<int, int> v1, v2, v3;
   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;
   }

multimap::pointer

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

typedef typename allocator_type::pointer pointer;

Observações

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

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

multimap::rbegin

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

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor de retorno

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

Observações

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

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

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

Exemplo

// multimap_rbegin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: reverse_iterator m1_rIter;
   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_rIter = m1.rbegin( );
   cout << "The first element of the reversed multimap m1 is "
        << m1_rIter -> first << "." << endl;

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

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

   // A multimap element can be erased by dereferencing its key
   m1_rIter = m1.rbegin( );
   m1.erase ( m1_rIter -> first );

   m1_rIter = m1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed multimap is "
        << m1_rIter -> first << "." << endl;
}

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

multimap::reference

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

typedef typename allocator_type::reference reference;

Exemplo

// multimap_ref.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   typedef pair <int, int> Int_Pair;

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

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

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

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

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

   cout << "The data value of first element in the 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 multimap is 1.
The data value of first element in the multimap is 10.
The modified data value of first element is 15.

multimap::rend

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

const_reverse_iterator rend() const;

reverse_iterator rend();

Valor de retorno

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

Observações

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

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

rend pode ser usado para testar se um iterador reverso atingiu o final de sua multimap.

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

Exemplo

// multimap_rend.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: reverse_iterator m1_rIter;
   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_rIter = m1.rend( );
   m1_rIter--;
   cout << "The last element of the reversed multimap m1 is "
        << m1_rIter -> first << "." << endl;

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

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

   // A multimap element can be erased by dereferencing to its key
   m1_rIter = --m1.rend( );
   m1.erase ( m1_rIter -> first );

   m1_rIter = m1.rend( );
   m1_rIter--;
   cout << "After the erasure, the last element "
        << "in the reversed multimap is "
        << m1_rIter -> first << "." << endl;
}

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

multimap::reverse_iterator

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

typedef std::reverse_iterator<iterator> reverse_iterator;

Observações

Um tipo reverse_iterator é usado para iterar através do inverso multimap .

O reverse_iterator definido por 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 reverse_iteratorrIter apontamento para um elemento em um multimap, use o -> operador .

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

Exemplo

Veja o exemplo para rbegin obter um exemplo de como declarar e usar reverse_iterator.

multimap::size

Devolve o número de elementos na multimap.

size_type size() const;

Valor de retorno

O comprimento atual do multimap.

Exemplo

O exemplo a seguir demonstra o uso da função member multimap::size .

// multimap_size.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main()
{
    using namespace std;
    multimap<int, int> m1, m2;
    multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

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

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

The multimap length is 1.
The multimap length is now 2.

multimap::size_type

Um tipo inteiro não assinado que conta o número de elementos em um multimaparquivo .

typedef typename allocator_type::size_type size_type;

Exemplo

Veja o exemplo para size obter um exemplo de como declarar e usar size_type

multimap::swap

Troca os elementos de dois multimaps.

void swap(
    multimap<Key, Type, Traits, Allocator>& right);

Parâmetros

right
O multimap que fornece os elementos a trocar, ou o multimap cujos elementos devem ser trocados com os do multimapleft.

Observações

A função de membro não invalida referências, ponteiros ou iteradores que designam elementos nos dois multimaps cujos elementos estão sendo trocados.

Exemplo

// multimap_swap.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1, m2, m3;
   multimap <int, int>::iterator m1_Iter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );
   m2.insert ( Int_Pair ( 10, 100 ) );
   m2.insert ( Int_Pair ( 20, 200 ) );
   m3.insert ( Int_Pair ( 30, 300 ) );

   cout << "The original multimap m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;

   // This is the member function version of swap
   m1.swap( m2 );

   cout << "After swapping with m2, multimap m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( m1, m3 );

   cout << "After swapping with m3, multimap m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;
}

The original multimap m1 is: 10 20 30.
After swapping with m2, multimap m1 is: 100 200.
After swapping with m3, multimap m1 is: 300.

multimap::upper_bound

Retorna um iterator para o primeiro elemento em um multimap que 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

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

Valor de retorno

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

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

Exemplo

// multimap_upper_bound.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <int, int> :: const_iterator m1_AcIter, m1_RcIter;
   typedef pair <int, int> Int_Pair;

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

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

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

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

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

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

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

multimap::value_comp

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

Observações

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

Exemplo

// multimap_value_comp.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;

   multimap <int, int, less<int> > m1;
   multimap <int, int, less<int> >::value_compare vc1 = m1.value_comp( );
   multimap<int,int>::iterator Iter1, Iter2;

   Iter1= m1.insert ( multimap <int, int> :: value_type ( 1, 10 ) );
   Iter2= m1.insert ( 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;
   }
}

The element ( 1,10 ) precedes the element ( 2,5 ).
The element ( 2,5 ) does not precede the element ( 1,10 ).

multimap::value_type

Um tipo que representa o tipo de objeto armazenado como um elemento em um mapa.

typedef pair<const Key, Type> value_type;

Exemplo

// multimap_value_type.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

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

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

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

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

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

   cout << "The data value of first element in the 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 = m1.begin( ) ; pIter != m1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

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

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

Ver também

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