hash_multimap (STL/CLR)

Artigo
06/10/2015

A classe do modelo descreve um objeto que controla uma sequência de variar- comprimento de elementos que tenha acesso bidirecional. Você usa o contêiner hash_multimap para gerenciar uma sequência de elementos como uma tabela de hash, cada entrada da tabela para armazenar uma lista vinculada bidirecional de nós, e cada nó armazenando um elemento. Um elemento consiste em uma chave, para ordenar a sequência, e um valor mapeado, desde que vai para o passeio.

Na descrição abaixo, GValue é o mesmo que:

Microsoft::VisualC::StlClr::GenericPair<GKey, GMapped>

onde:

GKey é o mesmo que Key a menos que o último é um tipo de referência, nesse caso é Key^

GMapped é o mesmo que Mapped a menos que o último é um tipo de referência, nesse caso é Mapped^

template<typename Key,
    typename Mapped>
    ref class hash_multimap
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        Microsoft::VisualC::StlClr::IHash<Gkey, GValue>
    { ..... };

Parâmetros

Chave
O tipo de componente principal de um elemento na sequência controlada.
Mapeado
O tipo de componente adicional de um elemento na sequência controlada.

Membros

Definição de tipo	Descrição
hash_multimap::const_iterator (STL/CLR)	O tipo de um iterador de constante para a sequência controlada.
hash_multimap::const_reference (STL/CLR)	O tipo de uma referência constante para um elemento.
hash_multimap::const_reverse_iterator (STL/CLR)	O tipo de um iterador invertido constante para a sequência controlada.
hash_multimap::difference_type (STL/CLR)	O tipo de distância de possivelmente (assinado) entre dois elementos.
hash_multimap::generic_container (STL/CLR)	O tipo de interface genérica para o contêiner.
hash_multimap::generic_iterator (STL/CLR)	O tipo de um iterador para a interface genérica para o contêiner.
hash_multimap::generic_reverse_iterator (STL/CLR)	O tipo de um iterador de cima para baixo para a interface genérica para o contêiner.
hash_multimap::generic_value (STL/CLR)	O tipo de um elemento para a interface genérica para o contêiner.
hash_multimap::hasher (STL/CLR)	A delegação de hash de uma chave.
hash_multimap::iterator (STL/CLR)	O tipo de um iterador para a sequência controlada.
hash_multimap::key_compare (STL/CLR)	O delegado de ordenação para duas chaves.
hash_multimap::key_type (STL/CLR)	O tipo de uma chave classificação.
hash_multimap::mapped_type (STL/CLR)	O tipo do valor mapeado associado a cada chave.
hash_multimap::reference (STL/CLR)	O tipo de uma referência para um elemento.
hash_multimap::reverse_iterator (STL/CLR)	O tipo de um iterador de cima para baixo para a sequência controlada.
hash_multimap::size_type (STL/CLR)	O tipo de distância (não negativo) de entre dois elementos.
hash_multimap::value_compare (STL/CLR)	O delegado de ordenação para dois valores do elemento.
hash_multimap::value_type (STL/CLR)	O tipo de um elemento.

Função de membro	Descrição
hash_multimap::begin (STL/CLR)	Designa o início da sequência controlada.
hash_multimap::bucket_count (STL/CLR)	Conta o número de segmentos.
hash_multimap::clear (STL/CLR)	Remove todos os elementos.
hash_multimap::count (STL/CLR)	Conta os elementos que correspondem a uma chave especificada.
hash_multimap::empty (STL/CLR)	Testa se nenhum elemento estiver presente.
hash_multimap::end (STL/CLR)	Designa o término da sequência controlada.
hash_multimap::equal_range (STL/CLR)	Encontra variam que corresponde a uma chave especificada.
hash_multimap::erase (STL/CLR)	Remove os elementos nas posições especificadas.
hash_multimap::find (STL/CLR)	Localiza um elemento que corresponde a uma chave especificada.
hash_multimap::hash_delegate (STL/CLR)	Copia a delegação de hash de uma chave.
hash_multimap::hash_multimap (STL/CLR)	Cria um objeto contêiner.
hash_multimap::insert (STL/CLR)	Adiciona os elementos.
hash_multimap::key_comp (STL/CLR)	Copia o representante de ordenação para duas chaves.
hash_multimap::load_factor (STL/CLR)	Conta os elementos médio por segmento.
hash_multimap::lower_bound (STL/CLR)	Localiza o início do intervalo que corresponde a uma chave especificada.
hash_multimap::make_value (STL/CLR)	Cria um objeto de valor.
hash_multimap::max_load_factor (STL/CLR)	Obtém ou define os elementos máximo pelo segmento.
hash_multimap::rbegin (STL/CLR)	Designa o início da sequência controlada invertida.
hash_multimap::rehash (STL/CLR)	Recria a tabela de hash.
hash_multimap::rend (STL/CLR)	Designa o término da sequência controlada invertida.
hash_multimap::size (STL/CLR)	Conta o número de elementos.
hash_multimap::swap (STL/CLR)	Alterna o conteúdo de dois contêineres.
hash_multimap::to_array (STL/CLR)	Copia a sequência controlada a uma nova matriz.
hash_multimap::upper_bound (STL/CLR)	Localiza de extremidade do intervalo que corresponde a uma chave especificada.
hash_multimap::value_comp (STL/CLR)	Copia o representante de ordenação para dois valores do elemento.

Operador	Descrição
hash_multimap::operator= (STL/CLR)	Substitui a sequência controlada.

Interfaces

Interface	Descrição
ICloneable	Duplica um objeto.
IEnumerable	Sequência por meio dos elementos.
ICollection	Mantenha o grupo de elementos.
IEnumerable	Sequência por meio dos elementos digitados.
ICollection	Mantenha o grupo de elementos de tipo.
IHashKey<, valor>	Mantenha o contêiner genérico.

Comentários

O objeto aloca e libera armazenamento para a sequência que controla como nós individuais em uma lista vinculada bidirecional. Para acelerar o acesso, o objeto também mantém uma matriz de variar- comprimento dos ponteiros na lista (a tabela de hash), gerenciando efetivamente a lista inteiro com uma sequência de sublists, ou blocos. Insere os elementos em um segmento que mantém ordenado alterando os links entre nós, nunca copiar o conteúdo de um nó para outro. Isso significa que você pode inserir e remover os elementos livremente sem os outros elementos de perturbação.

O objeto classifica cada partição que controla chamando um objeto armazenado delegado do tipo hash_set::key_compare (STL/CLR). Você pode especificar o objeto armazenado delegado quando você constrói o hash_set; se você não especificar um objeto de delegação, o padrão será a comparação operator<=(key_type, key_type).

Você acessa o objeto armazenado delegado chamando a função de membro hash_set::key_comp (STL/CLR)(). Esse objeto de delegação deve definir o equivalente de ordenação de chaves entre do tipo hash_set::key_type (STL/CLR). Isso significa que, para algumas duas chaves X e Y:

key_comp()(X, Y) retorna o mesmo resultado booliano em cada chamada.

Se key_comp()(X, Y) && key_comp()(Y, X) é true, então X e Y são ditos ter ordenação equivalente.

Qualquer regra de ordenação que se comportar como operator<=(key_type, key_type), operator>=(key_type, key_type)operator==(key_type, key_type) ou define a ordenação eqivalent.

Observe que o contêiner garante que apenas elementos cujas chaves têm a ordenação de equivalente (e quais picam com o mesmo valor inteiro) são adjacentes em um segmento. Ao contrário da classe hash_map (STL/CLR)do modelo, um objeto da classe hash_multimap do modelo não exige que as chaves para todos os elementos são exclusivos. (Dois ou mais chaves podem ter ordenação equivalente.)

O objeto determina qual segmento deve conter uma chave de classificação especificada chamando um objeto armazenado delegado do tipo hash_set::hasher (STL/CLR). Você acessa esse objeto armazenado chamando a função de membro hash_set::hash_delegate (STL/CLR)() para obter um valor inteiro que depende do valor da chave. Você pode especificar o objeto armazenado delegado quando você constrói o hash_set; se você não especificar um objeto de delegação, o padrão será a função System::Object::hash_value(key_type). Isso significa que, para algumas chaves X e Y:

hash_delegate()(X) retorna o mesmo resultado inteiro em cada chamada.

Se X e Y tem a ordenação equivalente, então hash_delegate()(X) deve retornar o mesmo resultado inteiro que hash_delegate()(Y).

Cada elemento contém uma chave separada e um valor mapeado. A sequência é representada de forma a permitir que a pesquisa, inserir, e a remoção de um elemento com um número arbitrário de operações que é independente do número de elementos na sequência (o tempo constantes) -- pelo menos no melhor dos casos. Além disso, inserindo um elemento não invalida iteradores, e removendo um elemento invalida apenas os iteradores que apontam no elemento removido.

Se os valores com hash não são distribuídos uniformemente, porém, um hash a tabela pode degenerar. Em extremamente -- para uma função de hash que sempre retorna o mesmo valor -- a pesquisa, inserir, e a remoção é proporcional ao número de elementos na sequência (hora lineares). O contêiner esforça-se escolher uma função de hash razoável, um tamanho médio do segmento, e uma tabela de hash (número total de blocos), mas você pode substituir algumas ou todas estas escolhas. Consulte, por exemplo, as funções hash_set::max_load_factor (STL/CLR) e hash_set::rehash (STL/CLR).

Um hash_multimap oferece suporte aos iteradores bidirecionais, o que significa que você pode avançar para os elementos adjacentes um iterador dados que designa um elemento na sequência controlada. Um nó principal especial corresponde ao iterador retornado por hash_multimap::end (STL/CLR)(). Você pode diminuir este iterador para alcançar o elemento o mais recente na sequência controlada, se houver. É possível incrementar um iterador de hash_multimap para alcançar o nó principal, e comparará no igual a end(). Mas você não pode desreferenciar o iterador retornado por end().

Observe que você não pode se referir a um elemento de hash_multimap determinado diretamente a posição numérica -- isso requer um iterador de acesso aleatório.

Um iterador de hash_multimap armazena um identificador para o nó associado de hash_multimap, por sua vez que armazena um identificador para o contêiner associado. Você pode usar iteradores apenas com seus objetos de contêiner associados. Um iterador de hash_multimap permanece válido desde que o nó associado de hash_multimap é associado a um hash_multimap. Além disso, um iterador válido é dereferencable -- você pode usá-lo para acessar ou modificar o valor do elemento que designa -- contanto que não é igual a end().

Apagando ou removendo um elemento chama o destruidor para seu valor armazenado. Destruir o contêiner apaga todos os elementos. Assim, um contêiner cujo tipo de elemento é uma classe de referência garante que nenhum elemento é maior que o contêiner. A observe, entretanto, que manipula um contêiner faz not destrói seus elementos.