hash_set (STL/CLR)

A classe de modelo descreve um objeto que controla uma sequência de tamanho variável de elementos que têm acesso bidirecional. Você usa o contêiner hash_set para gerenciar uma sequência de elementos como uma tabela de hash, cada entrada de tabela armazenando uma lista vinculada bidirecional de nós e cada nó armazenando um elemento. O valor de cada elemento é usado como uma chave para ordenar a sequência.

Na descrição abaixo, GValue é o mesmo GKeyque , que por sua vez é o mesmo Key que a menos que o último seja um tipo ref, caso em que é Key^.

Sintaxe

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

Key
O tipo do componente de chave de um elemento na sequência controlada.

Requisitos

Cabeçalho:<cliext/hash_set>

Namespace: cliext

Declarações

Definição do tipo	Descrição
hash_set::const_iterator	O tipo de um iterador de constante para a sequência controlada.
hash_set::const_reference	O tipo de uma referência de constante para um elemento.
hash_set::const_reverse_iterator	O tipo de um iterador reverso de constante para a sequência controlada.
hash_set::difference_type	O tipo de uma distância (possivelmente com sinal) entre dois elementos.
hash_set::generic_container	O tipo da interface genérica para o contêiner.
hash_set::generic_iterator	O tipo de um iterador da interface genérica para o contêiner.
hash_set::generic_reverse_iterator	O tipo de um iterador reverso da interface genérica para o contêiner.
hash_set::generic_value	O tipo de um elemento da interface genérica para o contêiner.
hash_set::hasher	O delegado de hash de uma chave.
hash_set::iterator	O tipo de um iterador para a sequência controlada.
hash_set::key_compare	O delegado de ordenação para duas chaves.
hash_set::key_type	O tipo de uma chave de classificação.
hash_set::reference	O tipo de uma referência para um elemento.
hash_set::reverse_iterator	O tipo de um iterador inverso para a sequência controlada.
hash_set::size_type	O tipo de uma distância (não negativa) entre dois elementos.
hash_set::value_compare	O delegado de ordenação para dois valores de elemento.
hash_set::value_type	O tipo de um elemento.

Função de membro	Descrição
hash_set::begin	Designa o início da sequência controlada.
hash_set::bucket_count	Conta o número de buckets.
hash_set::clear	Remove todos os elementos.
hash_set::count	Conta os elementos que correspondem a uma chave especificada.
hash_set::empty	Testa se nenhum elemento está presente.
hash_set::end	Designa o fim da sequência controlada.
hash_set::equal_range	Localiza o intervalo que corresponde a uma chave especificada.
hash_set::erase	Remove os elementos em posições especificadas.
hash_set::find	Localiza um elemento que corresponde a uma chave especificada.
hash_set::hash_delegate	Copia o delegado de hash de uma chave.
hash_set::hash_set	Constrói um objeto contêiner.
hash_set::insert	Adiciona elementos.
hash_set::key_comp	Copia o delegado de ordenação de duas chaves.
hash_set::load_factor	Conta a média de elementos por bucket.
hash_set::lower_bound	Localiza o início do intervalo que corresponde a uma chave especificada.
hash_set::make_value	Constrói um objeto de valor.
hash_set::max_load_factor	Obtém ou define o máximo de elementos por bucket.
hash_set::rbegin	Designa o início da sequência controlada invertida.
hash_set::rehash	Recria a tabela de hash.
hash_set::rend	Designa o fim da sequência controlada invertida.
hash_set::size	Conta o número de elementos.
hash_set::swap	Alterna o conteúdo de dois contêineres.
hash_set::to_array	Copia a sequência controlada para uma nova matriz.
hash_set::upper_bound	Localiza fim do intervalo que corresponde a uma chave especificada.
hash_set::value_comp	Copia o delegado de ordenação para dois valores de elemento.

Operador	Descrição
hash_set::operator=	Substitui a sequência controlada.

Interfaces

Interface	Descrição
ICloneable	Duplica um objeto.
IEnumerable	Sequencie por meio de elementos.
ICollection	Mantenha grupo de elementos.
IEnumerable<T>	Sequencie por meio de elementos de tipo.
ICollection<T>	Manter grupo de elementos tipados.
IHash<Key, Value>	Manter contêiner genérico.

Comentários

O objeto aloca e libera o armazenamento para a sequência que ele controla como nós individuais em uma lista vinculada bidirecional. Para acelerar o acesso, o objeto também mantém uma matriz de ponteiros de comprimento variado na lista (a tabela de hash), gerenciando efetivamente toda a lista como uma sequência de sublistas ou buckets. Ele insere elementos em um bucket que mantém ordenado alterando os links entre nós, nunca copiando o conteúdo de um nó para outro. Isso significa que você pode inserir e remover elementos livremente sem prejudicar os demais elementos.

O objeto ordena cada bucket que controla chamando um objeto delegado armazenado do tipo hash_set::key_compare. Você pode especificar o objeto delegado armazenado ao construir o hash_set; se especificar nenhum objeto delegado, o padrão será a comparação operator<=(key_type, key_type).

Você acessa o objeto delegado armazenado chamando a função hash_set::key_compde membro . Esse objeto delegado deve definir a ordenação equivalente entre chaves do tipo hash_set::key_type. Isso significa que, para duas chaves X e Y quaisquer:

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

Se key_comp()(X, Y) && key_comp()(Y, X) for verdadeiro, então X e Y terão ordenação equivalente.

Qualquer regra de ordenação que se comporte como operator<=(key_type, key_type), operator>=(key_type, key_type) ou operator==(key_type, key_type) defina ordenação equivalente.

O contêiner garante apenas que os elementos cujas chaves tenham ordenação equivalente (e quais hash para o mesmo valor inteiro) sejam adjacentes em um bucket. Diferente da classe de modelo hash_multiset (STL/CLR), um objeto da classe de modelo hash_set garante que as chaves para todos os elementos sejam exclusivas. (Não há duas chaves com ordenação equivalente.)

O objeto determina qual bucket deve conter uma determinada chave de ordenação chamando um objeto delegado armazenado do tipo hash_set::hasher. Você acessa esse objeto armazenado chamando a função hash_set::hash_delegate membro para obter um valor inteiro que depende do valor da chave. Você pode especificar o objeto delegado armazenado ao construir o hash_set; se não especificar nenhum objeto delegado, o padrão será a função System::Object::hash_value(key_type). Isso significa que para qualquer chave X e Y:

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

Se X e Y tiverem ordenação equivalente, hash_delegate()(X) deverá retornar o mesmo resultado inteiro que hash_delegate()(Y).

Cada elemento serve como uma chave e um valor. A sequência é representada de forma a permitir a pesquisa, inserção e remoção de um elemento arbitrário em tempo constante. Ou seja, o número de operações é independente do número de elementos na sequência, pelo menos no melhor dos casos. Além disso, Inserir um elemento não invalida iteradores, e remover um elemento invalida apenas os iteradores que apontam o elemento removido.

No entanto, se os valores de hash não forem distribuídos uniformemente, uma tabela de hash poderá degenerar. No extremo (para uma função hash que sempre retorna o mesmo valor), a pesquisa, a inserção e a remoção são proporcionais ao número de elementos na sequência (tempo linear). O contêiner busca escolher uma função de hash, um tamanho médio do bucket e um tamanho da tabela de hash (número total de buckets) razoáveis, mas você pode substituir qualquer uma dessas opções. Veja, por exemplo, as funções hash_set::max_load_factor e hash_set::rehash.

A hash_set dá suporte a iteradores bidirecionais, o que significa que você pode passar para elementos adjacentes com um iterador que designa um elemento na sequência controlada. Um nó de cabeçalho especial corresponde ao iterador retornado por end(). É possível decrementar esse iterador para alcançar o último elemento na sequência controlada, se presente. Você pode incrementar um hash_set iterador para alcançar o nó principal e, em seguida, ele será comparado a end(). Mas você não pode desreferenciar o iterador retornado por end().

Você não pode se referir a um hash_set elemento diretamente, dada sua posição numérica. Isso requer um iterador de acesso aleatório.

Um hash_set iterador armazena um identificador em seu nó associado hash_set , que, por sua vez, armazena um identificador em seu contêiner associado. Você somente pode usar iteradores com seus objetos de contêiner associados. Um hash_set iterador permanece válido desde que seu nó associado hash_set esteja associado a algum hash_set. Além disso, um iterador válido é desreferenciável. Você pode usá-lo para acessar ou alterar o valor do elemento que ele designa, desde que não seja igual a end().

Apagar ou remover um elemento chama o destruidor para o valor armazenado. Destruir o contêiner apaga todos os elementos. Portanto, um contêiner cujo tipo de elemento é uma classe ref garante que nenhum elemento sobreviva ao contêiner. No entanto, um contêiner de alças não destrói seus elementos.

Membros

hash_set::begin

Designa o início da sequência controlada.

Sintaxe

iterator begin();

Comentários

A função membro retorna um iterador bidirecional que designa o primeiro elemento da sequência controlada ou logo após o final de uma sequência vazia. Use-o para obter um iterador que designa o início current da sequência controlada, mas seu status poderá mudar se o tamanho da sequência controlada for alterado.

Exemplo

// cliext_hash_set_begin.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    Myhash_set::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);
    return (0);
    }

hash_set::bucket_count

Conta o número de buckets.

Sintaxe

int bucket_count();

Comentários

A função membro retorna o número atual de buckets. Use-a para determinar o tamanho da tabela de hash.

Exemplo

// cliext_hash_set_bucket_count.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

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

hash_set::clear

Remove todos os elementos.

Sintaxe

void clear();

Comentários

A função membro chama efetivamente erase(begin(), end()). Use para garantir que a sequência controlada esteja vazia.

Exemplo

// cliext_hash_set_clear.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    // add elements and clear again
    c1.insert(L'a');
    c1.insert(L'b');

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
size() = 0
a b
size() = 0

hash_set::const_iterator

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

Sintaxe

typedef T2 const_iterator;

Comentários

O tipo descreve um objeto de tipo não especificado T2 que pode servir como um iterador bidirecional constante para a sequência controlada.

Exemplo

// cliext_hash_set_const_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    Myhash_set::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_set::const_reference

O tipo de uma referência de constante para um elemento.

Sintaxe

typedef value_type% const_reference;

Comentários

O tipo descreve uma referência de constante para um elemento.

Exemplo

// cliext_hash_set_const_reference.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    Myhash_set::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Myhash_set::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_set::const_reverse_iterator

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

Sintaxe

typedef T4 const_reverse_iterator;

Comentários

O tipo descreve um objeto de tipo não especificado T4 que pode servir como um iterador reverso de constante para a sequência controlada.

Exemplo

// cliext_hash_set_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" reversed
    Myhash_set::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }

c b a

hash_set::count

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

Sintaxe

size_type count(key_type key);

Parâmetros

key
O valor chave a ser pesquisado.

Comentários

A função membro retorna o número de elementos na sequência controlada que têm ordenação equivalente com key. Usado para determinar o número de elementos que estão na sequência controlada no momento e que correspondem a uma chave especificada.

Exemplo

// cliext_hash_set_count.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("count(L'A') = {0}", c1.count(L'A'));
    System::Console::WriteLine("count(L'b') = {0}", c1.count(L'b'));
    System::Console::WriteLine("count(L'C') = {0}", c1.count(L'C'));
    return (0);
    }

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

hash_set::difference_type

Os tipos de uma distância com sinal entre dois elementos.

Sintaxe

typedef int difference_type;

Comentários

O tipo descreve uma contagem de elementos possivelmente negativa.

Exemplo

// cliext_hash_set_difference_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    Myhash_set::difference_type diff = 0;
    for (Myhash_set::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (Myhash_set::iterator it = c1.end(); it != c1.begin(); --it)
        --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

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

hash_set::empty

Testa se nenhum elemento está presente.

Sintaxe

bool empty();

Comentários

A função membro retorna verdadeiro para uma sequência controlada vazia. É equivalente a size() == 0. Você o usa para testar se o hash_set está vazio.

Exemplo

// cliext_hash_set_empty.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

a b c
size() = 3
empty() = False
size() = 0
empty() = True

hash_set::end

Designa o fim da sequência controlada.

Sintaxe

iterator end();

Comentários

A função membro retorna um iterador bidirecional que aponta para logo após o fim da sequência controlada. Você o usa para obter um iterador que designa o final da sequência controlada; Seu status não será alterado se o comprimento da sequência controlada for alterado.

Exemplo

// cliext_hash_set_end.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last two items
    Myhash_set::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);
    return (0);
    }

a b c
*-- --end() = b
*--end() = c

hash_set::equal_range

Localiza o intervalo que corresponde a uma chave especificada.

Sintaxe

cliext::pair<iterator, iterator> equal_range(key_type key);

Parâmetros

key
O valor chave a ser pesquisado.

Comentários

A função membro retorna um par de iteradores cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key)). Use-a para determinar o intervalo de elementos que estão atualmente na sequência controlada e que correspondem a uma chave especificada.

Exemplo

// cliext_hash_set_equal_range.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
typedef Myhash_set::pair_iter_iter Pairii;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display results of failed search
    Pairii pair1 = c1.equal_range(L'x');
    System::Console::WriteLine("equal_range(L'x') empty = {0}",
        pair1.first == pair1.second);

    // display results of successful search
    pair1 = c1.equal_range(L'b');
    for (; pair1.first != pair1.second; ++pair1.first)
        System::Console::Write("{0} ", *pair1.first);
    System::Console::WriteLine();
    return (0);
    }

a b c
equal_range(L'x') empty = True
b

hash_set::erase

Remove os elementos em posições especificadas.

Sintaxe

iterator erase(iterator where);
iterator erase(iterator first, iterator last);
bool erase(key_type key)

Parâmetros

first
Início do intervalo a ser apagado.

key
O valor da chave a ser apagada.

last
Fim do intervalo a ser apagado.

where
Elemento a ser apagado.

Comentários

A primeira função membro remove o elemento da sequência controlada apontada por where, e retorna um iterador que designa o primeiro elemento restante além do elemento removido ou end() se esse elemento não existir. Use para remover apenas um elemento.

A segunda função membro remove os elementos da sequência controlada no intervalo [first, last) e retorna um iterador que designa o primeiro elemento restante além de quaisquer elementos removidos ou end() se esse elemento não existir. Use para remover zero ou mais elementos contíguos.

A terceira função membro remove qualquer elemento da sequência controlada cuja chave tenha ordenação equivalente a key, e retorna uma contagem do número de elementos removidos. Use-a para remover e contar todos os elementos que correspondem a uma chave especificada.

Cada apagamento de elemento leva tempo proporcional ao logaritmo do número de elementos na sequência controlada.

Exemplo

// cliext_hash_set_erase.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase an element and reinspect
    System::Console::WriteLine("erase(begin()) = {0}",
        *c1.erase(c1.begin()));

    // add elements and display " b c d e"
    c1.insert(L'd');
    c1.insert(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase all but end
    Myhash_set::iterator it = c1.end();
    System::Console::WriteLine("erase(begin(), end()-1) = {0}",
        *c1.erase(c1.begin(), --it));
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1

hash_set::find

Localiza um elemento que corresponde a uma chave especificada.

Sintaxe

iterator find(key_type key);

Parâmetros

key
O valor chave a ser pesquisado.

Comentários

Se pelo menos um elemento na sequência controlada tiver uma ordenação equivalente com key, a função membro retornará um iterador designando um desses elementos; caso contrário, ela retornará end(). Use-a para localizar um elemento que está atualmente na sequência controlada e que corresponde a uma chave especificada.

Exemplo

// cliext_hash_set_find.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("find {0} = {1}",
        L'A', c1.find(L'A') != c1.end());
    System::Console::WriteLine("find {0} = {1}",
        L'b', *c1.find(L'b'));
    System::Console::WriteLine("find {0} = {1}",
        L'C', c1.find(L'C') != c1.end());
    return (0);
    }

a b c
find A = False
find b = b
find C = False

hash_set::generic_container

O tipo da interface genérica para o contêiner.

Sintaxe

typedef Microsoft::VisualC::StlClr::
    IHash<GKey, GValue>
    generic_container;

Comentários

O tipo descreve a interface genérica para essa classe de contêiner de modelo.

Exemplo

// cliext_hash_set_generic_container.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_set::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify original and display generic
    c1.insert(L'e');
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a b c d
a b c d e

hash_set::generic_iterator

O tipo de um iterador a ser usado com a interface genérica do contêiner.

Sintaxe

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerBidirectionalIterator<generic_value>
    generic_iterator;

Comentários

O tipo descreve um iterador genérico que pode ser usado com a interface genérica para essa classe de contêiner de modelo.

Exemplo

// cliext_hash_set_generic_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_set::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_set::generic_iterator gcit = gc1->begin();
    Myhash_set::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
a

hash_set::generic_reverse_iterator

O tipo de um iterador reverso a ser usado com a interface genérica para o contêiner.

Sintaxe

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value>
    generic_reverse_iterator;

Comentários

O tipo descreve um iterador reverso genérico que pode ser usado com a interface genérica para essa classe de contêiner de modelo.

Exemplo

// cliext_hash_set_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_set::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_set::generic_reverse_iterator gcit = gc1->rbegin();
    Myhash_set::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
c

hash_set::generic_value

O tipo de um elemento para uso com a interface genérica do contêiner.

Sintaxe

typedef GValue generic_value;

Comentários

O tipo descreve um objeto de tipo GValue que mostra o valor do elemento armazenado a ser usado com a interface genérica para essa classe de contêiner de modelo.

Exemplo

// cliext_hash_set_generic_value.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_set::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_set::generic_iterator gcit = gc1->begin();
    Myhash_set::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
a

hash_set::hash_delegate

Localiza um elemento que corresponde a uma chave especificada.

Sintaxe

hasher^ hash_delegate();

Comentários

A função membro retorna o delegado usado para converter um valor de chave em um inteiro. Use-a para fazer hash de uma chave.

Exemplo

// cliext_hash_set_hash_delegate.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::hasher^ myhash = c1.hash_delegate();

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }

hash(L'a') = 1616896120
hash(L'b') = 570892832

hash_set::hash_set

Constrói um objeto contêiner.

Sintaxe

hash_set();
explicit hash_set(key_compare^ pred);
hash_set(key_compare^ pred, hasher^ hashfn);
hash_set(hash_set<Key>% right);
hash_set(hash_set<Key>^ right);
template<typename InIter>
    hash_sethash_set(InIter first, InIter last);
template<typename InIter>
    hash_set(InIter first, InIter last,
        key_compare^ pred);
template<typename InIter>
    hash_set(InIter first, InIter last,
        key_compare^ pred, hasher^ hashfn);
hash_set(System::Collections::Generic::IEnumerable<GValue>^ right);
hash_set(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred);
hash_set(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred, hasher^ hashfn);

Parâmetros

first
Início do intervalo a ser inserido.

hashfn
Função de hash para mapear chaves para buckets.

last
Fim do intervalo a ser inserido.

pred
Predicado de ordenação para a sequência controlada.

right
Objeto ou intervalo a inserir.

Comentários

O construtor:

hash_set();

inicializa a sequência controlada sem elementos, com o predicado de ordenação padrão key_compare() e com a função de hash padrão. Use-o para especificar uma sequência controlada inicial vazia, com o a função de hash e o predicado de ordenação padrão.

O construtor:

explicit hash_set(key_compare^ pred);

inicializa a sequência controlada sem elementos, com o predicado predde ordenação e com a função de hash padrão. Use-o para especificar uma sequência controlada inicial vazia, com o predicado de ordenação especificado e a função de hash padrão.

O construtor:

hash_set(key_compare^ pred, hasher^ hashfn);

inicializa a sequência controlada sem elementos, com o predicado predde ordenação e com a função hashfnhash . Use-o para especificar uma sequência controlada inicial vazia, com o predicado de ordenação e a função de hash especificados.

O construtor:

hash_set(hash_set<Key>% right);

inicializa a sequência controlada com a sequência [right.begin(), right.end()), com o predicado de ordenação padrão e com a função de hash padrão. Você o usa para especificar uma sequência controlada inicial que é uma cópia da sequência controlada pelo hash_set objeto right, com o predicado de ordenação padrão e a função de hash.

O construtor:

hash_set(hash_set<Key>^ right);

inicializa a sequência controlada com a sequência [right->begin(), right->end()), com o predicado de ordenação padrão e com a função de hash padrão. Você o usa para especificar uma sequência controlada inicial que é uma cópia da sequência controlada pelo hash_set objeto right, com o predicado de ordenação padrão e a função de hash.

O construtor:

template<typename InIter> hash_set(InIter first, InIter last);

inicializa a sequência controlada com a sequência [first, last), com o predicado de ordenação padrão e com a função de hash padrão. Use-o para tornar a sequência controlada uma cópia de outra sequência, com o predicado de ordenação padrão e a função de hash.

O construtor:

template<typename InIter> hash_set(InIter first, InIter last, key_compare^ pred);

inicializa a sequência controlada com a sequência [first, last), com o predicado predde ordenação e com a função de hash padrão. Use-o para tornar a sequência controlada uma cópia de outra sequência, com o predicado de ordenação especificado e a função de hash padrão.

O construtor:

template<typename InIter> hash_set(InIter first, InIter last, key_compare^ pred, hasher^ hashfn);

inicializa a sequência controlada com a sequência [first, last), com o predicado predde ordenação e com a função hashfnhash . Use-o para tornar a sequência controlada uma cópia de outra sequência, com a função de hash e o predicado de ordenação especificados.

O construtor:

hash_set(System::Collections::Generic::IEnumerable<Key>^ right);

inicializa a sequência controlada com a sequência designada pelo enumerador right, com o predicado de ordenação padrão e com a função hash padrão. Use-o para tornar a sequência controlada uma cópia de outra sequência descrita por um enumerador, com a função de hash e o predicado de ordenação padrão.

O construtor:

hash_set(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred);

inicializa a sequência controlada com a sequência designada pelo enumerador right, com o predicado predde ordenação e com a função de hash padrão. Use-o para tornar a sequência controlada uma cópia de outra sequência descrita por um enumerador, com o predicado de ordenação especificado e a função de hash padrão.

O construtor:

hash_set(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred, hasher^ hashfn);

inicializa a sequência controlada com a sequência designada pelo enumerador right, com o predicado predde ordenação e com a função hashfnhash . Use-o para tornar a sequência controlada uma cópia de outra sequência descrita por um enumerador, com o predicado de ordenação especificado e a função de hash.

Exemplo

// cliext_hash_set_construct.cpp
// compile with: /clr
#include <cliext/hash_set>

int myfun(wchar_t key)
    { // hash a key
    return (key ^ 0xdeadbeef);
    }

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
// construct an empty container
    Myhash_set c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an ordering rule
    Myhash_set c2 = cliext::greater_equal<wchar_t>();
    System::Console::WriteLine("size() = {0}", c2.size());

    c2.insert(c1.begin(), c1.end());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an ordering rule and hash function
    Myhash_set c2h(cliext::greater_equal<wchar_t>(),
        gcnew Myhash_set::hasher(&myfun));
    System::Console::WriteLine("size() = {0}", c2h.size());

    c2h.insert(c1.begin(), c1.end());
    for each (wchar_t elem in c2h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an iterator range
    Myhash_set c3(c1.begin(), c1.end());
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule
    Myhash_set c4(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>());
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule and hash function
    Myhash_set c4h(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>(),
        gcnew Myhash_set::hasher(&myfun));
    for each (wchar_t elem in c4h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an enumeration
    Myhash_set c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
    for each (wchar_t elem in c5)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule
    Myhash_set c6(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3,
            cliext::greater_equal<wchar_t>());
    for each (wchar_t elem in c6)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule and hash function
    Myhash_set c6h(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3,
            cliext::greater_equal<wchar_t>(),
                gcnew Myhash_set::hasher(&myfun));
    for each (wchar_t elem in c6h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct from a generic container
    Myhash_set c7(c4);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    Myhash_set c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
a b c
size() = 0
a b c
size() = 0
c b a

a b c
a b c
c b a

a b c
a b c
c b a

a b c
a b c

hash_set::hasher

O delegado de hash de uma chave.

Sintaxe

Microsoft::VisualC::StlClr::UnaryDelegate<GKey, int>
    hasher;

Comentários

O tipo descreve um delegado que converte um valor de chave em um inteiro.

Exemplo

// cliext_hash_set_hasher.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::hasher^ myhash = c1.hash_delegate();

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }

hash(L'a') = 1616896120
hash(L'b') = 570892832

hash_set::insert

Adiciona elementos.

Sintaxe

cliext::pair<iterator, bool> insert(value_type val);
iterator insert(iterator where, value_type val);
template<typename InIter>
    void insert(InIter first, InIter last);
void insert(System::Collections::Generic::IEnumerable<value_type>^ right);

Parâmetros

first
Início do intervalo a ser inserido.

last
Fim do intervalo a ser inserido.

right
Enumeração a ser inserida.

val
Valor da chave a ser inserido.

where
Em que parte do contêiner inserir (somente uma dica).

Comentários

Cada uma das funções membro insere uma sequência especificada pelos operandos restantes.

A primeira função membro tenta inserir um elemento com valor val e retorna um par de valores X. Se X.second for verdadeiro, X.first designará o elemento recém-inserido, caso contrário, X.first designará um elemento com uma ordenação equivalente já existente, e nenhum novo elemento será inserido. Use para inserir um único elemento.

A segunda função membro insere um elemento com value val, usando where como dica (para melhorar o desempenho) e retorna um iterador que designa o elemento recém-inserido. Você o usa para inserir um único elemento que pode estar ao lado de um elemento que você conhece.

A terceira função membro insere a sequência [first, last). Use-a para inserir zero ou mais elementos copiados de outra sequência.

A quarta função membro insere a sequência designada pelo right. Use-a para inserir uma sequência descrita por um enumerador.

Cada inserção de elemento leva um tempo proporcional ao logaritmo do número de elementos na sequência controlada. A inserção pode ocorrer em tempo constante amortizado, no entanto, dada uma dica que designa um elemento próximo ao ponto de inserção.

Exemplo

// cliext_hash_set_insert.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
typedef Myhash_set::pair_iter_bool Pairib;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value, unique and duplicate
    Pairib pair1 = c1.insert(L'x');
    System::Console::WriteLine("insert(L'x') = [{0} {1}]",
        *pair1.first, pair1.second);

    pair1 = c1.insert(L'b');
    System::Console::WriteLine("insert(L'b') = [{0} {1}]",
        *pair1.first, pair1.second);

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value with hint
    System::Console::WriteLine("insert(begin(), L'y') = {0}",
        *c1.insert(c1.begin(), L'y'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an iterator range
    Myhash_set c2;
    Myhash_set::iterator it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an enumeration
    Myhash_set c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
insert(L'x') = [x True]
insert(L'b') = [b False]
a b c x
insert(begin(), L'y') = y
a b c x y
a b c x
a b c x y

hash_set::iterator

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

Sintaxe

typedef T1 iterator;

Comentários

O tipo descreve um objeto de tipo não especificado T1 que pode servir como um iterador bidirecional para a sequência controlada.

Exemplo

// cliext_hash_set_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    Myhash_set::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_set::key_comp

Copia o delegado de ordenação de duas chaves.

Sintaxe

key_compare^key_comp();

Comentários

A função membro retorna o delegado de ordenação usado para ordenar a sequência controlada. Use-o para comparar duas chaves.

Exemplo

// cliext_hash_set_key_comp.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Myhash_set c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

hash_set::key_compare

O delegado de ordenação para duas chaves.

Sintaxe

Microsoft::VisualC::StlClr::BinaryDelegate<GKey, GKey, bool>
    key_compare;

Comentários

O tipo é um sinônimo do delegado que determina a ordenação dos respectivos argumentos de chave.

Exemplo

// cliext_hash_set_key_compare.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Myhash_set c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

hash_set::key_type

O tipo de uma chave de classificação.

Sintaxe

typedef Key key_type;

Comentários

O tipo é um sinônimo do parâmetro de modeloKey.

Exemplo

// cliext_hash_set_key_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" using key_type
    for (Myhash_set::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Myhash_set::key_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_set::load_factor

Conta a média de elementos por bucket.

Sintaxe

float load_factor();

Comentários

A função membro retorna (float)size() / bucket_count(). Use-a para determinar o tamanho médio do bucket.

Exemplo

// cliext_hash_set_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

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

hash_set::lower_bound

Localiza o início do intervalo que corresponde a uma chave especificada.

Sintaxe

iterator lower_bound(key_type key);

Parâmetros

key
O valor chave a ser pesquisado.

Comentários

A função membro determina o primeiro elemento X na sequência controlada que faz hash para o mesmo bucket key e tem uma ordenação equivalente a key. Se esse elemento não existir, ele retornará end(); caso contrário, ele retornará um iterador que designa X. Use-a para localizar o início de uma sequência de elementos contidos atualmente na sequência controlada e que corresponde a uma chave especificada.

Exemplo

// cliext_hash_set_lower_bound.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("lower_bound(L'x')==end() = {0}",
        c1.lower_bound(L'x') == c1.end());

    System::Console::WriteLine("*lower_bound(L'a') = {0}",
        *c1.lower_bound(L'a'));
    System::Console::WriteLine("*lower_bound(L'b') = {0}",
        *c1.lower_bound(L'b'));
    return (0);
    }

a b c
lower_bound(L'x')==end() = True
*lower_bound(L'a') = a
*lower_bound(L'b') = b

hash_set::make_value

Constrói um objeto de valor.

Sintaxe

static value_type make_value(key_type key);

Parâmetros

key
Valor da chave a ser usada.

Comentários

A função membro retorna um value_type objeto cuja chave é key. Use-a para compor um objeto adequado para uso com várias outras funções membro.

Exemplo

// cliext_hash_set_make_value.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(Myhash_set::make_value(L'a'));
    c1.insert(Myhash_set::make_value(L'b'));
    c1.insert(Myhash_set::make_value(L'c'));

    // display contents " a b c"
    for each (Myhash_set::value_type elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_set::max_load_factor

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

Sintaxe

float max_load_factor();
void max_load_factor(float new_factor);

Parâmetros

new_factor
Novo fator de carga máxima a ser armazenado.

Comentários

A primeira função membro retorna o fator de carga máxima armazenada. Use-a para determinar o tamanho máximo médio do bucket.

A segunda função de membro substitui o fator de carga máxima de armazenamento por new_factor. Nenhuma rehash automático ocorre até uma inserção subsequente.

Exemplo

// cliext_hash_set_max_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

hash_set::operator=

Substitui a sequência controlada.

Sintaxe

hash_set<Key>% operator=(hash_set<Key>% right);

Parâmetros

right
O contêiner a ser copiado.

Comentários

O operador membro copia right para o objeto e retorna *this. Você pode usá-lo para substituir a sequência controlada por uma cópia da sequência controlada em right.

Exemplo

// cliext_hash_set_operator_as.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (Myhash_set::value_type elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    Myhash_set c2;
    c2 = c1;
// display contents " a b c"
    for each (Myhash_set::value_type elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c

hash_set::rbegin

Designa o início da sequência controlada invertida.

Sintaxe

reverse_iterator rbegin();

Comentários

A função membro retorna um iterador reverso que designa o último elemento da sequência controlada ou logo após o início de uma sequência vazia. Portanto, ele designa o beginning da sequência invertida. Use-o para obter um iterador que designa o início current da sequência controlada que é vista na ordem inversa, mas seu status poderá mudar se o tamanho da sequência controlada for alterado.

Exemplo

// cliext_hash_set_rbegin.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Myhash_set::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);
    return (0);
    }

a b c
*rbegin() = c
*++rbegin() = b

hash_set::reference

O tipo de uma referência para um elemento.

Sintaxe

typedef value_type% reference;

Comentários

O tipo descreve uma referência a um elemento.

Exemplo

// cliext_hash_set_reference.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    Myhash_set::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Myhash_set::reference ref = *it;
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_set::rehash

Recria a tabela de hash.

Sintaxe

void rehash();

Comentários

A função membro recria a tabela de hash, garantindo que load_factor() <= max_load_factor()o . Caso contrário, a tabela de hash aumentará de tamanho somente conforme necessário após uma inserção. (Ele nunca diminui de tamanho automaticamente). Você a usa para ajustar o tamanho da tabela de hash.

Exemplo

// cliext_hash_set_rehash.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

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

hash_set::rend

Designa o fim da sequência controlada invertida.

Sintaxe

reverse_iterator rend();

Comentários

A função membro retorna um iterador reverso que aponta para logo após o início da sequência controlada. Portanto, ele designa o end da sequência invertida. Use-o para obter um iterador que designa o fim current da sequência controlada vista na ordem inversa, mas seu status poderá mudar se o tamanho da sequência controlada for alterado.

Exemplo

// cliext_hash_set_rend.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    Myhash_set::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);
    return (0);
    }

a b c
*-- --rend() = b
*--rend() = a

hash_set::reverse_iterator

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

Sintaxe

typedef T3 reverse_iterator;

Comentários

O tipo descreve um objeto de tipo T3 não especificado que pode servir como um iterador reverso para a sequência controlada.

Exemplo

// cliext_hash_set_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" reversed
    Myhash_set::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }

c b a

hash_set::size

Conta o número de elementos.

Sintaxe

size_type size();

Comentários

A função membro retorna o comprimento da sequência controlada. Use para determinar o número de elementos que estão na sequência controlada no momento. Se tudo o que importa é se a sequência tem tamanho diferente de zero, consulte empty().

Exemplo

// cliext_hash_set_size.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0} starting with 3", c1.size());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.insert(L'a');
    c1.insert(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2

hash_set::size_type

O tipo de uma distância com sinal entre dois elementos.

Sintaxe

typedef int size_type;

Comentários

O tipo descreve uma contagem de elementos não negativos.

Exemplo

// cliext_hash_set_size_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    Myhash_set::size_type diff = 0;
    for (Myhash_set::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

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

hash_set::swap

Alterna o conteúdo de dois contêineres.

Sintaxe

void swap(hash_set<Key>% right);

Parâmetros

right
Contêiner com o qual trocar conteúdos.

Comentários

A função membro troca as sequências controladas entre this e right. É feito em um tempo constante e não gera exceções. Use como uma maneira rápida de trocar o conteúdo entre dois contêineres.

Exemplo

// cliext_hash_set_swap.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct another container with repetition of values
    Myhash_set c2;
    c2.insert(L'd');
    c2.insert(L'e');
    c2.insert(L'f');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
d e f
d e f
a b c

hash_set::to_array

Copia a sequência controlada para uma nova matriz.

Sintaxe

cli::array<value_type>^ to_array();

Comentários

A função membro retorna uma matriz que contém a sequência controlada. Use para obter uma cópia da sequência controlada em formato de matriz.

Exemplo

// cliext_hash_set_to_array.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // copy the container and modify it
    cli::array<wchar_t>^ a1 = c1.to_array();

    c1.insert(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c d
a b c

hash_set::upper_bound

Localiza fim do intervalo que corresponde a uma chave especificada.

Sintaxe

iterator upper_bound(key_type key);

Parâmetros

key
O valor chave a ser pesquisado.

Comentários

A função membro determina o último elemento X na sequência controlada que faz hash para o mesmo bucket key e tem uma ordenação equivalente a key. Se esse elemento não existir, ou se X for o último elemento na sequência controlada, ele retornará end(); caso contrário, ele retornará um iterador que designa o primeiro elemento além de X. Use para localizar o fim de uma sequência de elementos que estão na sequência controlada no momento e que correspondem a uma chave especificada.

Exemplo

// cliext_hash_set_upper_bound.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("upper_bound(L'x')==end() = {0}",
        c1.upper_bound(L'x') == c1.end());

    System::Console::WriteLine("*upper_bound(L'a') = {0}",
        *c1.upper_bound(L'a'));
    System::Console::WriteLine("*upper_bound(L'b') = {0}",
        *c1.upper_bound(L'b'));
    return (0);
    }

a b c
upper_bound(L'x')==end() = True
*upper_bound(L'a') = b
*upper_bound(L'b') = c

hash_set::value_comp

Copia o delegado de ordenação para dois valores de elemento.

Sintaxe

value_compare^ value_comp();

Comentários

A função membro retorna o delegado de ordenação usado para ordenar a sequência controlada. Use-a para comparar dois valores de elemento.

Exemplo

// cliext_hash_set_value_comp.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();
    return (0);
    }

compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

hash_set::value_compare

O delegado de ordenação para dois valores de elemento.

Sintaxe

Microsoft::VisualC::StlClr::BinaryDelegate<generic_value, generic_value, bool>
    value_compare;

Comentários

O tipo é um sinônimo do delegado que determina a ordenação dos argumentos de valor dessa sequência.

Exemplo

// cliext_hash_set_value_compare.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();
    return (0);
    }

compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

hash_set::value_type

O tipo de um elemento.

Sintaxe

typedef generic_value value_type;

Comentários

O tipo é um sinônimo de generic_value.

Exemplo

// cliext_hash_set_value_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" using value_type
    for (Myhash_set::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Myhash_set::value_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c