unordered_multiset Classe

2025-06-13

O modelo de classe descreve um objeto que controla uma sequência de comprimento variável de elementos do tipo const Key. A sequência é fracamente ordenada por uma função hash, que particiona a sequência em um conjunto ordenado de subsequências chamadas buckets. Dentro de cada bucket, uma função de comparação determina se qualquer par de elementos tem ordem equivalente. Cada elemento serve como uma chave de classificação e um valor. A sequência é representada de uma forma que permite a pesquisa, inserção e remoção de um elemento arbitrário com um número de operações que podem ser independentes do número de elementos na sequência (tempo constante), pelo menos quando todos os buckets são de comprimento aproximadamente igual. Na pior das hipóteses, quando todos os elementos estão em um bucket, o número de operações é proporcional ao número de elementos na sequência (tempo linear). Além disso, inserir um elemento invalida nenhum iterador e remover um elemento invalida apenas os iteradores que apontam para o elemento removido.

Sintaxe

template <class Key,
    class Hash = std::hash<Key>,
    class Pred = std::equal_to<Key>,
    class Alloc = std::allocator<Key>>
class unordered_multiset;

Parâmetros

Chave
O tipo de chave.

Hash
O tipo de objeto da função hash.

Pred
O tipo de objeto da função de comparação de igualdade.

Alloc
A classe alocator.

Membros

Definição de Tipo	Descrição
allocator_type	O tipo de alocador para gerenciar o armazenamento.
const_iterator	O tipo de iterador constante para a sequência controlada.
const_local_iterator	O tipo de um iterador de bucket constante para a sequência controlada.
const_pointer	O tipo de um ponteiro constante para um elemento.
const_reference	O tipo de referência constante a um elemento.
difference_type	O tipo de distância assinada entre dois elementos.
Hasher	O tipo da função hash.
iterador	O tipo de iterador para a sequência controlada.
key_equal	O tipo da função de comparação.
key_type	O tipo de uma chave de ordenação.
local_iterator	O tipo de um iterador de bucket para a sequência controlada.
ponteiro	O tipo de um ponteiro para um elemento.
referência	O tipo de referência a um elemento.
size_type	O tipo de uma distância não assinada entre dois elementos.
value_type	O tipo de um elemento.

Função de Membro	Descrição
começar	Designa o início da sequência controlada.
balde	Obtém o número do bucket para um valor de chave.
bucket_count	Obtém o número de buckets.
bucket_size	Obtém o tamanho de um balde.
Cbegin	Designa o início da sequência controlada.
Curva	Designa o final da sequência controlada.
claro	Remove todos os elementos.
contém^C++20	Verifica se há um elemento com a chave especificada.
contagem	Localiza o número de elementos correspondentes a uma chave especificada.
Colocar	Adiciona um elemento construído no local.
emplace_hint	Adiciona um elemento construído no lugar, com dica.
vazio	Testa se nenhum elemento está presente.
fim	Designa o final da sequência controlada.
equal_range	Localiza o intervalo que corresponde a uma chave especificada.
apagar	Remove elementos em posições especificadas.
encontrar	Localiza um elemento que corresponde a uma chave especificada.
get_allocator	Obtém o objeto alocador armazenado.
hash_function	Obtém o objeto de função hash armazenado.
inserir	Adiciona elementos.
key_eq	Obtém o objeto de função de comparação armazenado.
load_factor	Conta a média de elementos por bucket.
max_bucket_count	Obtém o número máximo de buckets.
max_load_factor	Obtém ou define o máximo de elementos por bucket.
max_size	Obtém o tamanho máximo da sequência controlada.
rehash	Reconstrói a tabela de hash.
tamanho	Conta o número de elementos.
trocar	Troca o conteúdo de dois contêineres.
unordered_multiset	Constrói um objeto de contêiner.

Operador	Descrição
unordered_multiset::operador=	Copia uma tabela de hash.

Observações

O objeto ordena a sequência que controla chamando dois objetos armazenados, um objeto de função de comparação do tipo unordered_multiset::key_equal e um objeto de função hash do tipo unordered_multiset::hasher. Você acessa o primeiro objeto armazenado chamando a função de membro unordered_multiset::key_eq(); e acessa o segundo objeto armazenado chamando a função de membro unordered_multiset::hash_function(). Especificamente, para todos os valores X e Y do tipo Key, o key_eq()(X, Y) de chamada retornará true somente se os dois valores de argumento tiverem ordem equivalente; A chamada hash_function()(keyval) produz uma distribuição de valores do tipo size_t. Ao contrário do modelo unordered_setde classe, um objeto do tipo unordered_multiset não garante que key_eq()(X, Y) seja sempre falso para quaisquer dois elementos da sequência controlada. (As chaves não precisam ser exclusivas.)

O objeto também armazena um fator de carga máximo, que especifica o número médio máximo desejado de elementos por bucket. Se a inserção de um elemento fizer com que unordered_multiset::load_fator() exceda o fator de carga máximo, o contêiner aumentará o número de buckets e reconstruirá a tabela de hash conforme necessário.

A ordem real dos elementos na sequência controlada depende da função hash, da função de comparação, da ordem de inserção, do fator de carga máximo e do número atual de buckets. Em geral, não é possível prever a ordem dos elementos na sequência controlada. Você sempre pode ter certeza, no entanto, de que qualquer subconjunto de elementos que tenham ordenação equivalente são adjacentes na sequência controlada.

O objeto aloca e libera armazenamento para a sequência que controla por meio de um objeto alocador armazenado do tipo unordered_multiset::allocator_type. Esse objeto alocador deve ter a mesma interface externa que um objeto do tipo allocator. Observe que o objeto alocador armazenado não é copiado quando o objeto contêiner é atribuído.

Requerimentos

Cabeçalho:<unordered_set>

Espaço de nomes: std

unordered_multiset::allocator_type

O tipo de alocador para gerenciar o armazenamento.

typedef Alloc allocator_type;

Observações

O tipo é um sinônimo para o parâmetro de modelo Alloc.

Exemplo

// std__unordered_set__unordered_multiset_allocator_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
    Myset c1;

    Myset::allocator_type al = c1.get_allocator();
    std::cout << "al == std::allocator() is "
        << std::boolalpha << (al == Myalloc()) << std::endl;

    return (0);
}

al == std::allocator() is true

unordered_multiset::começar

Designa o início da sequência controlada ou um balde.

iterator begin();

const_iterator begin() const;

local_iterator begin(size_type nbucket);

const_local_iterator begin(size_type nbucket) const;

Parâmetros

nbucket
O número do balde.

Observações

As duas primeiras funções de membro retornam um iterador avançado que aponta para o primeiro elemento da sequência (ou logo após o final de uma sequência vazia). As duas últimas funções de membro retornam um iterador de encaminhamento que aponta para o primeiro elemento de bucket nbucket (ou logo após o final de um bucket vazio).

Exemplo

// std__unordered_set__unordered_multiset_begin.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect first two items "[c] [b]"
    Myset::iterator it2 = c1.begin();
    std::cout << "[" << *it2 << "] ";
    ++it2;
    std::cout << "[" << *it2 << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[c] [b]
[a]

unordered_multiset::balde

Obtém o número do bucket para um valor de chave.

size_type bucket(const Key& keyval) const;

Parâmetros

Keyval
O valor-chave a ser mapeado.

Observações

A função member retorna o número do bucket atualmente correspondente ao valor de chave keyval.

Exemplo

// std__unordered_set__unordered_multiset_bucket.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display buckets for keys
    Myset::size_type bs = c1.bucket('a');
    std::cout << "bucket('a') == " << bs << std::endl;
    std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
        << std::endl;

    return (0);
}

[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1

unordered_multiset::bucket_count

Obtém o número de buckets.

size_type bucket_count() const;

Observações

A função member retorna o número atual de buckets.

Exemplo

// std__unordered_set__unordered_multiset_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multiset::bucket_size

Obtém o tamanho de um balde

size_type bucket_size(size_type nbucket) const;

Parâmetros

nbucket
O número do balde.

Observações

As funções de membro retornam o tamanho do número do bucket nbucket.

Exemplo

// std__unordered_set__unordered_multiset_bucket_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display buckets for keys
    Myset::size_type bs = c1.bucket('a');
    std::cout << "bucket('a') == " << bs << std::endl;
    std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
        << std::endl;

    return (0);
}

[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1

unordered_multiset::cbegin

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

const_iterator cbegin() const;

Valor de retorno

Um const iterador de acesso direto que aponta para o primeiro elemento do intervalo ou para 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 automático , 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

unordered_multiset::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 direto 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 automático , 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.

unordered_multiset::limpar

Remove todos os elementos.

void clear();

Observações

A função de membro chama unordered_multiset::erase(unordered_multiset::begin(),unordered_multiset::end()).

Exemplo

// std__unordered_set__unordered_multiset_clear.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}

[c] [b] [a]
size == 0
empty() == true

[e] [d]
size == 2
empty() == false

unordered_multiset::const_iterator

O tipo de iterador constante para a sequência controlada.

typedef T1 const_iterator;

Observações

O tipo descreve um objeto que pode servir como um iterador de encaminhamento constante para a sequência controlada. É descrito aqui como sinônimo do tipo T1definido pela implementação.

Exemplo

// std__unordered_set__unordered_multiset_const_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::const_local_iterator

O tipo de um iterador de bucket constante para a sequência controlada.

typedef T5 const_local_iterator;

Observações

O tipo descreve um objeto que pode servir como um iterador de encaminhamento constante para um bucket. É descrito aqui como sinônimo do tipo T5definido pela implementação.

Exemplo

// std__unordered_set__unordered_multiset_const_local_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a]

unordered_multiset::const_pointer

O tipo de um ponteiro constante para um elemento.

typedef Alloc::const_pointer const_pointer;

Observações

O tipo descreve um objeto que pode servir como um ponteiro constante para um elemento da sequência controlada.

Exemplo

// std__unordered_set__unordered_multiset_const_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::const_pointer p = &*it;
        std::cout << "[" << *p << "] ";
        }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::const_reference

O tipo de referência constante a um elemento.

typedef Alloc::const_reference const_reference;

Observações

O tipo descreve um objeto que pode servir como uma referência constante a um elemento da sequência controlada.

Exemplo

// std__unordered_set__unordered_multiset_const_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::const_reference ref = *it;
        std::cout << "[" << ref << "] ";
        }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::contém

Verifica se há um elemento com a chave especificada no unordered_multiset.

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

Parâmetros

K
O tipo da chave.

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

Exemplo

// Requires /std:c++20 or /std:c++latest
#include <unordered_set>
#include <iostream>

int main()
{
    std::unordered_multiset<int> theUnorderedMultiset = { 1, 2, 3 };

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

    return 0;
}

true
false

unordered_multiset::contagem

Localiza o número de elementos correspondentes a uma chave especificada.

size_type count(const Key& keyval) const;

Parâmetros

Keyval
Valor chave para pesquisar.

Observações

A função de membro retorna o número de elementos no intervalo delimitado por unordered_multiset::equal_range(keyval).

Exemplo

// std__unordered_set__unordered_multiset_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "count('A') == " << c1.count('A') << std::endl;
    std::cout << "count('b') == " << c1.count('b') << std::endl;
    std::cout << "count('C') == " << c1.count('C') << std::endl;

    return (0);
}

[c] [b] [a]
count('A') == 0
count('b') == 1
count('C') == 0

unordered_multiset::d ifference_type

O tipo de distância assinada entre dois elementos.

typedef T3 difference_type;

Observações

O tipo inteiro assinado descreve um objeto que pode representar a diferença entre os endereços de quaisquer dois elementos na sequência controlada. É descrito aqui como sinônimo do tipo T3definido pela implementação.

Exemplo

// std__unordered_set__unordered_multiset_difference_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // compute positive difference
    Myset::difference_type diff = 0;
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        ++diff;
    std::cout << "end()-begin() == " << diff << std::endl;

    // compute negative difference
    diff = 0;
    for (Myset::const_iterator it = c1.end();
        it != c1.begin(); --it)
        --diff;
    std::cout << "begin()-end() == " << diff << std::endl;

    return (0);
}

[c] [b] [a]
end()-begin() == 3
begin()-end() == -3

unordered_multiset::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 unordered_multiset.

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 inserção, se uma exceção for lançada, mas não ocorrer na função hash do contêiner, o contêiner não será modificado. Se a exceção for lançada na função hash, o resultado será indefinido.

Para obter um exemplo de código, consulte multiset::emplace.

unordered_multiset::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 unordered_multiset.

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

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.

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

unordered_multiset::vazio

Testa se nenhum elemento está presente.

bool empty() const;

Observações

A função de membro retorna true para uma sequência controlada vazia.

Exemplo

// std__unordered_set__unordered_multiset_empty.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}

[c] [b] [a]
size == 0
empty() == true

[e] [d]
size == 2
empty() == false

unordered_multiset::fim

Designa o final da sequência controlada.

iterator end();
const_iterator end() const;
local_iterator end(size_type nbucket);
const_local_iterator end(size_type nbucket) const;

Parâmetros

nbucket
O número do balde.

Observações

As duas primeiras funções de membro retornam um iterador avançado que aponta logo após o final da sequência. As duas últimas funções de membro retornam um iterador de encaminhamento que aponta logo além do final do bucket nbucket.

Exemplo

// std__unordered_set__unordered_multiset_end.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect last two items "[a] [b]"
    Myset::iterator it2 = c1.end();
    --it2;
    std::cout << "[" << *it2 << "] ";
    --it2;
    std::cout << "[" << *it2 << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.end(c1.bucket('a'));
    --lit;
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a] [b]
[a]

unordered_multiset::equal_range

Localiza o intervalo que corresponde a uma chave especificada.

std::pair<iterator, iterator>
    equal_range(const Key& keyval);

std::pair<const_iterator, const_iterator>
    equal_range(const Key& keyval) const;

Parâmetros

Keyval
Valor chave para pesquisar.

Observações

A função membro retorna um par de iteradores X de tal forma que [X.first, X.second) delimita apenas os elementos da sequência controlada que têm ordenação equivalente com keyval. Se tais elementos não existirem, ambos os iteradores serão end().

Exemplo

// std__unordered_set__unordered_multiset_equal_range.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display results of failed search
    std::pair<Myset::iterator, Myset::iterator> pair1 =
        c1.equal_range('x');
    std::cout << "equal_range('x'):";
    for (; pair1.first != pair1.second; ++pair1.first)
        std::cout << "[" << *pair1.first << "] ";
    std::cout << std::endl;

    // display results of successful search
    pair1 = c1.equal_range('b');
    std::cout << "equal_range('b'):";
    for (; pair1.first != pair1.second; ++pair1.first)
        std::cout << "[" << *pair1.first << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
equal_range('x'):
equal_range('b'): [b]

unordered_multiset::apagar

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

Onde
Posição do elemento a remover.

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

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

Chave
O valor-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 fim do unordered_multiset se tal elemento não existir.

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

Observações

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

unordered_multiset::encontrar

Localiza um elemento que corresponde a uma chave especificada.

const_iterator find(const Key& keyval) const;

Parâmetros

Keyval
Valor chave para pesquisar.

Observações

A função de membro retorna unordered_multiset::equal_range(keyval).first.

Exemplo

// std__unordered_set__unordered_multiset_find.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // try to find and fail
    std::cout << "find('A') == "
        << std::boolalpha << (c1.find('A') != c1.end()) << std::endl;

    // try to find and succeed
    Myset::iterator it = c1.find('b');
    std::cout << "find('b') == "
        << std::boolalpha << (it != c1.end())
        << ": [" << *it << "] " << std::endl;

    return (0);
}

[c] [b] [a]
find('A') == false
find('b') == true: [b]

unordered_multiset::get_allocator

Obtém o objeto alocador armazenado.

Alloc get_allocator() const;

Observações

A função member retorna o objeto alocador armazenado.

Exemplo

// std__unordered_set__unordered_multiset_get_allocator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
    Myset c1;

    Myset::allocator_type al = c1.get_allocator();
    std::cout << "al == std::allocator() is "
        << std::boolalpha << (al == Myalloc()) << std::endl;

    return (0);
}

al == std::allocator() is true

unordered_multiset::hash_function

Obtém o objeto de função hash armazenado.

Hash hash_function() const;

Observações

A função member retorna o objeto de função hash armazenado.

Exemplo

// std__unordered_set__unordered_multiset_hash_function.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::hasher hfn = c1.hash_function();
    std::cout << "hfn('a') == " << hfn('a') << std::endl;
    std::cout << "hfn('b') == " << hfn('b') << std::endl;

    return (0);
}

hfn('a') == 1630279
hfn('b') == 1647086

unordered_multiset::hasher

O tipo da função hash.

typedef Hash hasher;

Observações

O tipo é um sinônimo para o parâmetro de modelo Hash.

Exemplo

// std__unordered_set__unordered_multiset_hasher.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::hasher hfn = c1.hash_function();
    std::cout << "hfn('a') == " << hfn('a') << std::endl;
    std::cout << "hfn('b') == " << hfn('b') << std::endl;

    return (0);
}

hfn('a') == 1630279
hfn('b') == 1647086

unordered_multiset::inserir

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

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

Onde
O lugar para começar a procurar o ponto correto de inserção.

ValTy
Parâmetro de modelo que especifica o tipo de argumento que o unordered_multiset pode usar para construir um elemento de value_type e encaminha perfeitamente Val como um argumento.

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

Última
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 iterador de entrada que aponta para elementos de um tipo que podem ser usados para construir objetos value_type .

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

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

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, mas não ocorrer na função hash do contêiner, o estado do contêiner não será modificado. Se a exceção for lançada na função hash, o resultado será indefinido. 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 set, unordered_multiset<V>::value_type é type const V.

A função de membro do intervalo (5) insere a sequência de valores de elementos em um unordered_multiset que corresponde a cada elemento abordado por um iterador no intervalo [First, Last), portanto, Last não é inserido. 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 unordered_multiset.

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

Para obter um exemplo de código, consulte multiset::insert.

unordered_multiset::iterador

Um tipo que fornece um iterador de encaminhamento constante que pode ler elementos em um unordered_multiset.

typedef implementation-defined iterator;

Exemplo

Veja o exemplo para começar para obter um exemplo de como declarar e usar um iterador.

unordered_multiset::key_eq

Obtém o objeto de função de comparação armazenado.

Pred key_eq() const;

Observações

A função member retorna o objeto de função de comparação armazenado.

Exemplo

// std__unordered_set__unordered_multiset_key_eq.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::key_equal cmpfn = c1.key_eq();
    std::cout << "cmpfn('a', 'a') == "
        << std::boolalpha << cmpfn('a', 'a') << std::endl;
    std::cout << "cmpfn('a', 'b') == "
        << std::boolalpha << cmpfn('a', 'b') << std::endl;

    return (0);
}

cmpfn('a', 'a') == true
cmpfn('a', 'b') == false

unordered_multiset::key_equal

O tipo da função de comparação.

typedef Pred key_equal;

Observações

O tipo é um sinônimo para o parâmetro de modelo Pred.

Exemplo

// std__unordered_set__unordered_multiset_key_equal.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::key_equal cmpfn = c1.key_eq();
    std::cout << "cmpfn('a', 'a') == "
        << std::boolalpha << cmpfn('a', 'a') << std::endl;
    std::cout << "cmpfn('a', 'b') == "
        << std::boolalpha << cmpfn('a', 'b') << std::endl;

    return (0);
}

cmpfn('a', 'a') == true
cmpfn('a', 'b') == false

unordered_multiset::key_type

O tipo de uma chave de ordenação.

typedef Key key_type;

Observações

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

Exemplo

// std__unordered_set__unordered_multiset_key_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // add a value and reinspect
    Myset::key_type key = 'd';
    Myset::value_type val = key;
    c1.insert(val);

    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[d] [c] [b] [a]

unordered_multiset::load_fator

Conta a média de elementos por bucket.

float load_factor() const;

Observações

A função de membro retorna (float)unordered_multiset::size() / (float)unordered_multiset::bucket_count(), o número médio de elementos por bucket.

Exemplo

// std__unordered_set__unordered_multiset_load_factor.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}

unordered_multiset::local_iterator

O tipo de um iterador de bucket.

typedef T4 local_iterator;

Observações

O tipo descreve um objeto que pode servir como um iterador de encaminhamento para um bucket. É descrito aqui como sinônimo do tipo T4definido pela implementação.

Exemplo

// std__unordered_set__unordered_multiset_local_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a]

unordered_multiset::max_bucket_count

Obtém o número máximo de buckets.

size_type max_bucket_count() const;

Observações

A função member retorna o número máximo de buckets atualmente permitido.

Exemplo

// std__unordered_set__unordered_multiset_max_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multiset::max_load_fator

Obtém ou define o máximo de elementos por bucket.

float max_load_factor() const;

void max_load_factor(float factor);

Parâmetros

fator
O novo fator de carga máximo.

Observações

A primeira função de membro retorna o fator de carga máximo armazenado. A segunda função de membro substitui o fator de carga máximo armazenado pelo fator.

Exemplo

// std__unordered_set__unordered_multiset_max_load_factor.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multiset::max_size

Obtém o tamanho máximo da sequência controlada.

size_type max_size() const;

Observações

A função member retorna o comprimento da sequência mais longa que o objeto pode controlar.

Exemplo

// std__unordered_set__unordered_multiset_max_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    std::cout << "max_size() == " << c1.max_size() << std::endl;

    return (0);
}

max_size() == 4294967295

unordered_multiset::operador=

Copia uma tabela de hash.

unordered_multiset& operator=(const unordered_multiset& right);

unordered_multiset& operator=(unordered_multiset&& right);

Parâmetros

direito
O unordered_multiset sendo copiado para o unordered_multiset.

Observações

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

Exemplo

// unordered_multiset_operator_as.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

int main( )
{
    using namespace std;
    unordered_multiset<int> v1, v2, v3;
    unordered_multiset<int>::iterator iter;

    v1.insert(10);

    cout << "v1 = " ;
    for (iter = v1.begin(); iter != v1.end(); iter++)
        cout << *iter << " ";
    cout << endl;

    v2 = v1;
    cout << "v2 = ";
    for (iter = v2.begin(); iter != v2.end(); iter++)
        cout << *iter << " ";
    cout << endl;

    // move v1 into v2
    v2.clear();
    v2 = move(v1);
    cout << "v2 = ";
    for (iter = v2.begin(); iter != v2.end(); iter++)
        cout << *iter << " ";
    cout << endl;
}

unordered_multiset::p ointer

O tipo de um ponteiro para um elemento.

typedef Alloc::pointer pointer;

Observações

O tipo descreve um objeto que pode servir como um ponteiro para um elemento da sequência controlada.

Exemplo

// std__unordered_set__unordered_multiset_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::key_type key = *it;
        Myset::pointer p = &key;
        std::cout << "[" << *p << "] ";
        }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::referência

O tipo de referência a um elemento.

typedef Alloc::reference reference;

Observações

O tipo descreve um objeto que pode servir como referência a um elemento da sequência controlada.

Exemplo

// std__unordered_set__unordered_multiset_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::key_type key = *it;
        Myset::reference ref = key;
        std::cout << "[" << ref << "] ";
        }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::rehash

Reconstrói a tabela de hash.

void rehash(size_type nbuckets);

Parâmetros

nbuckets
O número solicitado de buckets.

Observações

A função de membro altera o número de buckets para ser pelo menos nbuckets e reconstrói a tabela de hash conforme necessário.

Exemplo

// std__unordered_set__unordered_multiset_rehash.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_load_factor() == 0.1

unordered_multiset::tamanho

Conta o número de elementos.

size_type size() const;

Observações

A função de membro retorna o comprimento da sequência controlada.

Exemplo

// std__unordered_set__unordered_multiset_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}

[c] [b] [a]
size == 0
empty() == true

[e] [d]
size == 2
empty() == false

unordered_multiset::size_type

O tipo de uma distância não assinada entre dois elementos.

typedef T2 size_type;

Observações

O tipo inteiro não assinado descreve um objeto que pode representar o comprimento de qualquer sequência controlada. É descrito aqui como sinônimo do tipo T2definido pela implementação.

Exemplo

// std__unordered_set__unordered_multiset_size_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;
    Myset::size_type sz = c1.size();

    std::cout << "size == " << sz << std::endl;

    return (0);
}

size == 0

unordered_multiset::swap

Troca o conteúdo de dois contêineres.

void swap(unordered_multiset& right);

Parâmetros

direito
O recipiente com o qual trocar.

Observações

A função de membro troca as sequências controladas entre *this e direito. Se unordered_multiset::get_allocator() == right.get_allocator(), ele faz isso em tempo constante, ele lança uma exceção apenas como resultado da cópia do objeto de características armazenadas do tipo Tr, e não invalida referências, ponteiros ou iteradores que designam elementos nas duas sequências controladas. Caso contrário, ele executa um número de atribuições de elementos e chamadas de construtor proporcionais ao número de elementos nas duas sequências controladas.

Exemplo

// std__unordered_set__unordered_multiset_swap.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    Myset c2;

    c2.insert('d');
    c2.insert('e');
    c2.insert('f');

    c1.swap(c2);

    // display contents "[f] [e] [d]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    swap(c1, c2);

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[f] [e] [d]
[c] [b] [a]

unordered_multiset::unordered_multiset

Constrói um objeto de contêiner.

unordered_multiset(
    const unordered_multiset& Right);

explicit unordered_multiset(
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

unordered_multiset(
    unordered_multiset&& Right);

unordered_set(
    initializer_list<Type> IList);

unordered_set(
    initializer_list<Typ> IList,
    size_type Bucket_count);

unordered_set(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash);

unordered_set(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    const Key& Key);

unordered_set(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    const Key& Key,
    const Allocator& Al);

template <class InputIterator>
unordered_multiset(
    InputIterator First,
    InputIterator Last,
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

Parâmetros

InputIterator
O tipo de iterador.

Al
O objeto alocador a ser armazenado.

Comp
O objeto de função de comparação a ser armazenado.

Hash
O objeto de função hash a ser armazenado.

Bucket_count
O número mínimo de buckets.

Direito
O recipiente a copiar.

IList
O initializer_list do qual copiar.

Observações

O primeiro construtor especifica uma cópia da sequência controlada por Right. O segundo construtor especifica uma sequência controlada vazia. O terceiro construtor insere a sequência de valores de elemento [First, Last). O quarto construtor especifica uma cópia da sequência movendo Right.

Todos os construtores também inicializam vários valores armazenados. Para o construtor copy, os valores são obtidos de Right. Caso contrário:

O número mínimo de buckets é o argumento Bucket_count, se presente; caso contrário, é um valor padrão descrito aqui como o valor N0definido pela implementação .

O objeto da função hash é o argumento Hash, se presente; caso contrário, é Hash().

O objeto da função de comparação é o argumento Comp, se presente; caso contrário, é Comp().

O objeto alocador é o argumento Al, se presente; caso contrário, é Alloc().

unordered_multiset::value_type

O tipo de um elemento.

typedef Key value_type;

Observações

O tipo descreve um elemento da sequência controlada.

Exemplo

// std__unordered_set__unordered_multiset_value_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // add a value and reinspect
    Myset::key_type key = 'd';
    Myset::value_type val = key;
    c1.insert(val);

    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[d] [c] [b] [a]

Ver também

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

Partilhar via

unordered_multiset Classe

Sintaxe

Parâmetros

Membros

Observações

Requerimentos

unordered_multiset::allocator_type

Observações

Exemplo

unordered_multiset::começar

Parâmetros

Observações

Exemplo

unordered_multiset::balde

Parâmetros

Observações

Exemplo

unordered_multiset::bucket_count

Observações

Exemplo

unordered_multiset::bucket_size

Parâmetros

Observações

Exemplo

unordered_multiset::cbegin

Valor de retorno

Observações

unordered_multiset::cend

Valor de retorno

Observações

unordered_multiset::limpar

Observações

Exemplo

unordered_multiset::const_iterator

Observações

Exemplo

unordered_multiset::const_local_iterator

Observações

Exemplo

unordered_multiset::const_pointer

Observações

Exemplo

unordered_multiset::const_reference

Observações

Exemplo

unordered_multiset::contém

Parâmetros

Valor de retorno

Observações

Exemplo

unordered_multiset::contagem

Parâmetros

Observações

Exemplo

unordered_multiset::d ifference_type

Observações

Exemplo

unordered_multiset::emplace

Parâmetros

Valor de retorno

Observações

unordered_multiset::emplace_hint

Parâmetros

Valor de retorno

Observações

unordered_multiset::vazio

Observações

Exemplo

unordered_multiset::fim

Parâmetros

Observações

Exemplo

unordered_multiset::equal_range

Parâmetros

Observações

Exemplo

unordered_multiset::apagar

Parâmetros

Valor de retorno