hash_set (STL/CLR)
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_set 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.O valor de cada elemento é usado como uma chave para a seqüência de pedidos.
Na descrição abaixo, GValue é o mesmo que GKey, que por sua vez é o mesmo que Key , a menos que o último é um tipo de referência, caso em que é Key^.
template<typename Key>
ref class hash_set
: 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.
Membros
Definição de tipo |
Descrição |
|---|---|
O tipo de um iterador constante para a seqüência controlada. |
|
O tipo de uma referência constante a um elemento. |
|
O tipo de um iterador inverso constante para a seqüência controlada. |
|
O tipo de uma distância (possivelmente assinado) entre dois elementos. |
|
O tipo de interface genérica para o recipiente. |
|
O tipo de um iterador para a interface genérica para o recipiente. |
|
O tipo de um iterador inverso para a interface genérica para o recipiente. |
|
O tipo de um elemento da interface genérica para o recipiente. |
|
O delegado de hash para uma chave. |
|
O tipo de um iterador para a seqüência controlada. |
|
O delegado pedido de duas chaves. |
|
O tipo de uma chave de ordenação. |
|
O tipo de uma referência a um elemento. |
|
O tipo de um iterador inverso para a seqüência controlada. |
|
O tipo de uma distância (não negativo) entre dois elementos. |
|
O delegado pedido para dois valores de elemento. |
|
O tipo de um elemento. |
Função de membro |
Descrição |
|---|---|
Designa o início da seqüência controlada. |
|
Conta o número de compartimentos de memória. |
|
Remove todos os elementos. |
|
Contagens de elementos correspondentes a uma chave especificada. |
|
Testes se elementos não estão presentes. |
|
Designa o final da seqüência controlada. |
|
Localiza o intervalo que corresponde a uma chave especificada. |
|
Remove os elementos em posições especificadas. |
|
Localiza um elemento que coincida com uma chave especificada. |
|
Copia o delegado hash para uma chave. |
|
Constrói um objeto de recipiente. |
|
Adiciona elementos. |
|
Copia o delegado pedido de duas chaves. |
|
Conta os elementos médio por compartimento de memória. |
|
Localiza o início do intervalo que corresponde a uma chave especificada. |
|
Constrói um objeto de valor. |
|
Obtém ou define os elementos máximo por compartimento de memória. |
|
Designa o início da seqüência controlada revertida. |
|
Recria a tabela de hash. |
|
Designa o final da seqüência controlada revertida. |
|
Conta o número de elementos. |
|
Troca o conteúdo dos dois recipientes. |
|
Copia a seqüência controlada para uma nova matriz. |
|
Localiza o final do intervalo que corresponde a uma chave especificada. |
|
Copia o delegate pedido para dois valores de elemento. |
Operator |
Descrição |
|---|---|
Substitui a seqüência controlada. |
Interfaces
Interface |
Descrição |
|---|---|
Duplica um objeto. |
|
Por meio de elementos na seqüência. |
|
Manter o grupo de elementos. |
|
Seqüência pelos elementos digitados. |
|
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_multiset (STL/CLR), um objeto de classe de modelo hash_set assegura que as chaves para todos os elementos são exclusivas.(Nenhuma duas chaves têm equivalentes ordenação.)
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 serve como uma chave e um valor.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_set 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_set::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_set 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_set diretamente dado sua posição numérica – o que requer um iterador de acesso aleatório.
Um iterador hash_set armazena um identificador de nó hash_set 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_set permanece válido desde que seu nó hash_set associado está associado com alguns hash_set.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.
Requisitos
Cabeçalho: < cliext/hash_set >
Namespace: cliext