hash_multimap (STL/CLR)

Artigo
02/25/2013

A classe de modelo descreve um objeto que controla uma seqüência de comprimento variando de elementos que tem acesso bidirecional.Use o contêiner hash_multimap para gerenciar uma seqüência de elementos como uma tabela de hash, cada entrada da tabela armazenar um bidirecional vinculado a lista de nós e cada nó de armazenamento de um elemento.Um elemento consiste em uma chave, para pedidos a seqüência e um valor mapeado, que vai para a jornada.

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

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

onde:

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

GMappedé o mesmo que Mapped , a menos que o último é um tipo de referência, caso em que é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 fundamental de um elemento na seqüência controlada.
Mapeados
O tipo de componente adicional de um elemento na seqüência controlada.

Membros

Definição de tipo	Descrição
hash_multimap::const_iterator (STL/CLR)	O tipo de um iterador constante para a seqüência controlada.
hash_multimap::const_reference (STL/CLR)	O tipo de uma referência constante a um elemento.
hash_multimap::const_reverse_iterator (STL/CLR)	O tipo de um iterador inverso constante para a seqüência controlada.
hash_multimap::difference_type (STL/CLR)	O tipo de uma distância (possivelmente assinado) entre dois elementos.
hash_multimap::generic_container (STL/CLR)	O tipo de interface genérica para o recipiente.
hash_multimap::generic_iterator (STL/CLR)	O tipo de um iterador para a interface genérica para o recipiente.
hash_multimap::generic_reverse_iterator (STL/CLR)	O tipo de um iterador inverso para a interface genérica para o recipiente.
hash_multimap::generic_value (STL/CLR)	O tipo de um elemento da interface genérica para o recipiente.
hash_multimap::hasher (STL/CLR)	O delegado de hash para uma chave.
hash_multimap::Iterator (STL/CLR)	O tipo de um iterador para a seqüência controlada.
hash_multimap::key_compare (STL/CLR)	O delegado pedido de duas chaves.
hash_multimap::key_type (STL/CLR)	O tipo de uma chave de ordenação.
hash_multimap::mapped_type (STL/CLR)	O tipo de valor mapeado associado a cada chave.
hash_multimap::Reference (STL/CLR)	O tipo de uma referência a um elemento.
hash_multimap::reverse_iterator (STL/CLR)	O tipo de um iterador inverso para a seqüência controlada.
hash_multimap::size_type (STL/CLR)	O tipo de uma distância (não negativo) entre dois elementos.
hash_multimap::value_compare (STL/CLR)	O delegado pedido para dois valores de 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 seqüência controlada.
hash_multimap::bucket_count (STL/CLR)	Conta o número de compartimentos de memória.
hash_multimap::Clear (STL/CLR)	Remove todos os elementos.
hash_multimap::Count (STL/CLR)	Contagens de elementos correspondentes a uma chave especificada.
hash_multimap::Empty (STL/CLR)	Testes se elementos não estão presentes.
hash_multimap::end (STL/CLR)	Designa o final da seqüência controlada.
hash_multimap::equal_range (STL/CLR)	Localiza o intervalo que corresponde a uma chave especificada.
hash_multimap::Erase (STL/CLR)	Remove os elementos em posições especificadas.
hash_multimap::Find (STL/CLR)	Localiza um elemento que coincida com uma chave especificada.
hash_multimap::hash_delegate (STL/CLR)	Copia o delegado hash para uma chave.
hash_multimap::hash_multimap (STL/CLR)	Constrói um objeto de recipiente.
hash_multimap::Insert (STL/CLR)	Adiciona elementos.
hash_multimap::key_comp (STL/CLR)	Copia o delegado pedido de duas chaves.
hash_multimap::load_factor (STL/CLR)	Conta os elementos médio por compartimento de memória.
hash_multimap::lower_bound (STL/CLR)	Localiza o início do intervalo que corresponde a uma chave especificada.
hash_multimap::make_value (STL/CLR)	Constrói um objeto de valor.
hash_multimap::max_load_factor (STL/CLR)	Obtém ou define os elementos máximo por compartimento de memória.
hash_multimap::rbegin (STL/CLR)	Designa o início da seqüência controlada revertida.
hash_multimap::rehash (STL/CLR)	Recria a tabela de hash.
hash_multimap::rend (STL/CLR)	Designa o final da seqüência controlada revertida.
hash_multimap::Size (STL/CLR)	Conta o número de elementos.
hash_multimap::swap (STL/CLR)	Troca o conteúdo dos dois recipientes.
hash_multimap::to_array (STL/CLR)	Copia a seqüência controlada para uma nova matriz.
hash_multimap::upper_bound (STL/CLR)	Localiza o final do intervalo que corresponde a uma chave especificada.
hash_multimap::value_comp (STL/CLR)	Copia o delegate pedido para dois valores de elemento.

Operator	Descrição
hash_multimap::Operator = (STL/CLR)	Substitui a seqüência controlada.

Interfaces

Interface	Descrição
ICloneable	Duplica um objeto.
IEnumerable	Por meio de elementos na seqüência.
ICollection	Manter o grupo de elementos.
IEnumerable<T>	Seqüência pelos elementos digitados.
ICollection<T>	Manter o grupo de elementos digitados.
IHash < chave, valor >	Manter um contêiner genérico.

Comentários

O objeto aloca e libera o armazenamento para a seqüência que ele controla como nós individuais em uma lista vinculada bidirecional.Para agilizar o acesso, o objeto também mantém uma matriz de comprimento variando de ponteiros para a lista (tabela hash), gerenciar com eficiência toda a lista como uma seqüência de sublistas, ou buckets.Ele insere elementos em um bucket que mantém ordenada alterando os links entre os nós nunca copiando o conteúdo de um nó para outro.Isso significa que você pode inserir e remover elementos livremente sem atrapalhar elementos restantes.

O objeto ordena cada bucket controla chamando um objeto delegado armazenado do tipo hash_set::key_compare (STL/CLR).Você pode especificar o objeto delegado armazenado quando você construir hash_set; Se você não especificar nenhum objeto delegado, o padrão é a comparação operator<=(key_type, key_type).

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

key_comp()(X, Y)Retorna o Boolean mesmo resultar em cada chamada.

Se key_comp()(X, Y) && key_comp()(Y, X) for true, em seguida, X e Y disse ter pedido equivalente.

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

Observe que o recipiente garante apenas que elementos cujas chaves têm equivalentes ordenação (e o hash para o mesmo valor de número inteiro) são adjacentes dentro de um Balde.Ao contrário da classe de modelo hash_map (STL/CLR), um objeto de classe de modelo hash_multimap não requer chaves para todos os elementos são exclusivas.(Duas ou mais teclas podem ter pedido equivalente).

O objeto determina qual bucket deve conter uma determinada chave pedida chamando um objeto delegado armazenado do tipo hash_set::hasher (STL/CLR).Acessar este objeto armazenado chamando a função de membro hash_set::hash_delegate (STL/CLR)() para obter um valor inteiro que varia de acordo com o valor da chave.Você pode especificar o objeto delegado armazenado quando você construir hash_set; Se você não especificar nenhum objeto delegado, o padrão é a função System::Object::hash_value(key_type).Isso significa que, de todas as chaves X e Y:

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

Se X e Y ter pedido equivalente, em seguida, hash_delegate()(X) deve retornar o mesmo resultado inteiro como hash_delegate()(Y).

Cada elemento contém uma chave e um valor mapeado.A seqüência é representada de forma que permite a pesquisa, inserção e remoção de um elemento arbitrário com um número de operações é independente do número de elementos na seqüência (tempo constante)-- pelo menos no melhor dos casos.Além disso, inserir um elemento invalida não iteradores e remover um elemento invalida os iteradores que apontem para o elemento removido.

Se os valores de hash não estão distribuídos uniformemente, no entanto, uma tabela de hash resultar pode na.Extremo - para uma função de hash que sempre retorna o mesmo valor - pesquisa, inserção e remoção são proporcionais ao número de elementos na seqüência (tempo linear).Portanto o recipiente escolher uma função hash razoável, o tamanho do bucket média e tamanho da tabela de hash (número total de depósitos), mas você pode substituir qualquer ou todas essas opções.Ver, por exemplo, as funções hash_set::max_load_factor (STL/CLR) e hash_set::rehash (STL/CLR).

Um hash_multimap suporta iteradores bidirecional, o que significa que passo dadas um iterador que designa um elemento na seqüência controlada de elementos adjacentes.Um nó principal especial corresponde ao iterador retornado por hash_multimap::end (STL/CLR)().Você pode diminuir este iterador para alcançar o último elemento na seqüência controlada, se presente.Você pode incrementar um iterador hash_multimap para alcançar o nó principal e, em seguida, comparar igual a end().Mas não cancelam o iterador retornado por end().

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

Um iterador hash_multimap armazena um identificador de nó hash_multimap associada, que por sua vez armazena um identificador de seu contêiner associado.Você pode usar iteradores somente com seus objetos de recipiente associado.Um iterador hash_multimap permanece válido desde que seu nó hash_multimap associado está associado com alguns hash_multimap.Além disso, um iterador válido é dereferencable--ele pode ser usado para acessar ou alterar o valor do elemento designa – desde que não é igual a end().

Apagar ou remover um elemento chama o destruidor para o valor armazenado.Destruir o recipiente apaga todos os elementos.Assim, um recipiente cujo tipo de elemento é uma classe ref garante que nenhum elemento outlive no recipiente.Entretanto, observe que um recipiente de alças não not destruir seus elementos.