hash_set Classe

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

A classe de contêiner hash_set é uma extensão da biblioteca padrão C++ e é usada para o armazenamento e recuperação rápida de dados de uma coleção na qual os valores dos elementos contidos são exclusivos e servem como os valores-chave.

Sintaxe

template <class Key,
    class Traits=hash_compare<Key, less<Key>>,
    class Allocator=allocator<Key>>
class hash_set

Parâmetros

Chave
O tipo de dados do elemento a ser armazenado no hash_set.

Traços
O tipo que inclui dois objetos de função, um de comparação de classe que é um predicado binário capaz de comparar dois valores de elemento como chaves de classificação para determinar sua ordem relativa e uma função hash que é um predicado unário mapeando valores de chave dos elementos para inteiros não assinados do tipo size_t. Esse argumento é opcional e o é o hash_compare<Key, less<Key> > valor padrão.

Alocador
O tipo que representa o objeto de alocador armazenado que encapsula detalhes sobre a alocação e desalocação de memória do hash_set. Esse argumento é opcional e o valor padrão é allocator<Key>.

Observações

O hash_set é:

Um contêiner associativo, que é um contêiner de tamanho variável que suporta a recuperação eficiente de valores de elemento com base em um valor de chave associado. Além disso, é um contêiner associativo simples porque seus valores de elemento são seus valores-chave.
Reversível, porque fornece um iterador bidirecional para acessar seus elementos.
Hashed, porque seus elementos são agrupados em buckets com base no valor de uma função hash aplicada aos valores-chave dos elementos.
Único no sentido de que cada um dos seus elementos deve ter uma chave única. Como hash_set também é um simples recipiente associativo, seus elementos também são únicos.
Um modelo de classe porque a funcionalidade que ele fornece é genérica e, portanto, independente do tipo específico de dados contidos como elementos ou chaves. Os tipos de dados a serem usados para elementos e chaves são, em vez disso, especificados como parâmetros no modelo de classe, juntamente com a função de comparação e o alocador.

A principal vantagem do hashing sobre a classificação é maior eficiência; Um hashing bem-sucedido executa inserções, exclusões e encontra em tempo médio constante em comparação com um tempo proporcional ao logaritmo do número de elementos no contêiner para técnicas de classificação. O valor de um elemento em um conjunto não pode ser alterado diretamente. Em vez disso, você deve excluir valores antigos e inserir elementos com novos valores.

A escolha do tipo de contentor deve basear-se, em geral, no tipo de pesquisa e inserção exigido pela aplicação. Os contentores associativos Hashed são otimizados para as operações de pesquisa, inserção e remoção. As funções de membro que suportam explicitamente essas operações são eficientes quando usadas com uma função hash bem projetada, executando-as em um tempo que é, em média, constante e não dependente do número de elementos no contêiner. Uma função de hash bem projetada produz uma distribuição uniforme de valores hashed e minimiza o número de colisões, onde uma colisão ocorre quando valores de chave distintos são mapeados no mesmo valor hash. Na pior das hipóteses, com a pior função hash possível, o número de operações é proporcional ao número de elementos na sequência (tempo linear).

O hash_set deve ser o recipiente associativo de escolha quando as condições que associam os valores às suas chaves são satisfeitas pela aplicação. Os elementos de um hash_set são únicos e servem como suas próprias chaves de classificação. Um modelo para este tipo de estrutura é uma lista ordenada de, digamos, palavras em que as palavras podem ocorrer apenas uma vez. Se várias ocorrências das palavras fossem permitidas, então um hash_multiset seria a estrutura de contêiner apropriada. Se os valores precisarem ser anexados a uma lista de palavras-chave exclusivas, uma hash_map seria uma estrutura apropriada para conter esses dados. Se, em vez disso, as chaves não são únicas, então um hash_multimap seria o recipiente de escolha.

O hash_set ordena a sequência que controla chamando um objeto hash Traits armazenado do tipo value_compare. Este objeto armazenado pode ser acessado chamando a função de membro key_comp. Tal objeto de função deve se comportar da mesma forma que um objeto de classe hash_compare<Key, menos<Key>>. Especificamente, para todos os valores key do tipo Key, a chamada Trait(key) produz uma distribuição de valores do tipo size_t.

Em geral, os elementos precisam ser apenas menos do que comparáveis para estabelecer essa ordem: de modo que, dados quaisquer dois elementos, pode-se determinar que eles são equivalentes (no sentido de que nenhum é menor que o outro) ou que um é menor que o outro. Isso resulta em uma ordenação entre os elementos não equivalentes. Em uma nota mais técnica, a função de comparação é um predicado binário que induz uma ordenação fraca estrita no sentido matemático padrão. Um predicado binário f( x, y) é um objeto de função que tem dois objetos de argumento x e y e um valor de retorno de true ou false. Uma ordenação imposta a um hash_set é uma ordenação fraca estrita se o predicado binário é irreflexivo, antisimétrico e transitivo e se a equivalência é transitiva, onde dois objetos x e y são definidos como equivalentes quando f( x, y) e f( y, x) são falsos. Se a condição mais forte de igualdade entre chaves substitui a de equivalência, então a ordenação torna-se total (no sentido de que todos os elementos são ordenados uns em relação aos outros) e as chaves combinadas serão indiscerníveis umas das outras.

A ordem real dos elementos na sequência controlada depende da função hash, da função de ordenação e do tamanho atual da tabela de hash armazenada no objeto container. Não é possível determinar o tamanho atual da tabela de hash, portanto, em geral, não é possível prever a ordem dos elementos na sequência controlada. A inserção de elementos não invalida nenhum iterador e a remoção de elementos invalida apenas os iteradores que apontaram especificamente para os elementos removidos.

O iterador fornecido pela classe hash_set é um iterador bidirecional, mas as funções de membro da classe inserem e hash_set têm versões que tomam como parâmetros de modelo um iterador de entrada mais fraco, cujos requisitos de funcionalidade são mais mínimos do que aqueles garantidos pela classe de iteradores bidirecionais. Os diferentes conceitos de iterador formam uma família relacionada por refinamentos em sua funcionalidade. Cada conceito de iterador tem seu próprio conjunto de requisitos, e os algoritmos que trabalham com eles devem limitar suas suposições aos requisitos fornecidos por esse tipo de iterador. Pode-se supor que um iterador de entrada pode ser desreferenciado para se referir a algum objeto e que ele pode ser incrementado para o próximo iterador na sequência. Este é um conjunto mínimo de funcionalidades, mas é suficiente para ser capaz de falar significativamente sobre uma gama de iteradores [ first, last) no contexto das funções de membro da classe.

Construtores

Construtor	Descrição
hash_set	Constrói um `hash_set` que está vazio ou que é uma cópia de todo ou parte de algum outro `hash_set`.

Typedefs (definições de tipos)

Nome do tipo	Descrição
allocator_type	Um tipo que representa a classe `allocator` para o objeto `hash_set`.
const_iterator	Um tipo que fornece um iterador bidirecional que pode ler um `const` elemento no `hash_set`.
const_pointer	Um tipo que fornece um ponteiro para um `const` elemento em um `hash_set`arquivo .
const_reference	Um tipo que fornece uma referência a um elemento `const` armazenado em um `hash_set` para ler e executar operações `const`.
const_reverse_iterator	Um tipo que fornece um iterador bidirecional que pode ler qualquer `const` elemento no `hash_set`.
difference_type	Um tipo de inteiro assinado que pode ser usado para representar o número de elementos de a `hash_set` em um intervalo entre elementos apontados por iteradores.
iterador	Um tipo que fornece um iterador bidirecional que pode ler ou modificar qualquer elemento em um `hash_set`arquivo .
key_compare	Um tipo que fornece um objeto de função que pode comparar duas chaves de classificação para determinar a ordem relativa de dois elementos no `hash_set`.
key_type	Um tipo que descreve um objeto armazenado como um elemento de a `hash_set` em sua capacidade como chave de classificação.
ponteiro	Um tipo que fornece um ponteiro para um elemento em um `hash_set`.
referência	Um tipo que fornece uma referência a um elemento armazenado em um `hash_set`.
reverse_iterator	Um tipo que fornece um iterador bidirecional que pode ler ou modificar um elemento em um arquivo `hash_set`.
size_type	Um tipo inteiro não assinado que pode representar o número de elementos em um `hash_set`arquivo .
value_compare	Um tipo que fornece dois objetos de função, um predicado binário de comparação de classe que pode comparar dois valores de elemento de a `hash_set` para determinar sua ordem relativa e um predicado unário que hashes os elementos.
value_type	Um tipo que descreve um objeto armazenado como um elemento de a `hash_set` em sua capacidade como um valor.

Funções de membro

Função de membro	Descrição
começar	Retorna um iterador que aborda o primeiro elemento no `hash_set`.
Cbegin	Retorna um iterador const endereçando o primeiro elemento no `hash_set`.
Curva	Retorna um iterador const que aborda o local que sucede o último elemento em um `hash_set`arquivo .
claro	Apaga todos os elementos de um `hash_set`.
contagem	Retorna o número de elementos em uma `hash_set` cuja chave corresponde a uma chave especificada por parâmetro.
Crstart	Retorna um iterador const endereçando o primeiro elemento em um arquivo `hash_set`.
Crend	Retorna um iterador const que aborda o local que sucede o último elemento em um arquivo `hash_set`.
Colocar	Insere um elemento construído no local em um `hash_set`arquivo .
emplace_hint	Insere um elemento construído no lugar em um `hash_set`, com uma dica de posicionamento.
vazio	Testa se um `hash_set` está vazio.
fim	Retorna um iterador que aborda o local que sucede o último elemento em um `hash_set`.
equal_range	Retorna um par de iteradores respectivamente para o primeiro elemento em um `hash_set` com uma chave que é maior do que uma chave especificada e para o `hash_set` primeiro elemento no com uma chave que é igual ou maior que a chave.
apagar	Remove um elemento ou um intervalo de elementos em um `hash_set` de posições especificadas ou remove elementos que correspondem a uma chave especificada.
encontrar	Retorna um iterador endereçando o local de um elemento em um `hash_set` que tem uma chave equivalente a uma chave especificada.
get_allocator	Retorna uma cópia do `allocator` objeto usado para construir o `hash_set`arquivo .
inserir	Insere um elemento ou um intervalo de elementos em um `hash_set`arquivo .
key_comp	Recupera uma cópia do objeto de comparação usado para ordenar chaves em um `hash_set`arquivo .
lower_bound	Retorna um iterador para o primeiro elemento em um `hash_set` com uma chave que é igual ou maior do que uma chave especificada.
max_size	Devolve o comprimento máximo da `hash_set`.
rcomeçar	Retorna um iterador endereçando o primeiro elemento em um arquivo `hash_set`.
rend	Retorna um iterador que aborda o local que sucede o último elemento em uma `hash_set`invertida.
tamanho	Devolve o número de elementos na `hash_set`.
trocar	Troca os elementos de dois `hash_set`s.
upper_bound	Retorna um iterador para o primeiro elemento em um `hash_set` que com uma chave que é igual ou maior do que uma chave especificada.
value_comp	Recupera uma cópia do objeto de traços de hash usado para hash e valores de chave de elemento de ordem em um `hash_set`arquivo .

Operadores

Operador	Descrição
hash_set::operador=	Substitui os elementos de um `hash_set` por uma cópia de outro `hash_set`.

Requerimentos

Cabeçalho:<hash_set>

Espaço de nomes: stdext

hash_set::allocator_type

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo que representa a classe de alocador para o objeto hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::allocator_type allocator_type;

Observações

allocator_type é um sinônimo para o parâmetro de modelo Allocator.

Para obter mais informações sobre o Allocator, consulte a seção Comentários do tópico Classe hash_set .

Exemplo

Veja o exemplo para get_allocator para um exemplo que usa allocator_typeo .

hash_set::começar

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Retorna um iterador que aborda o primeiro elemento no hash_set.

const_iterator begin() const;

iterator begin();

Valor de retorno

Um iterador bidirecional endereçando o primeiro elemento no hash_set ou o local que sucede um hash_set vazio.

Observações

Se o valor de retorno de begin for atribuído a um const_iterator, os elementos no objeto hash_set não poderão ser modificados. Se o valor de retorno de begin for atribuído a um iterator, os elementos no objeto hash_set poderão ser modificados.

Exemplo

// hash_set_begin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;
   hash_set <int>::const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_Iter = hs1.begin( );
   cout << "The first element of hs1 is " << *hs1_Iter << endl;

   hs1_Iter = hs1.begin( );
   hs1.erase( hs1_Iter );

   // The following 2 lines would err because the iterator is const
   // hs1_cIter = hs1.begin( );
   // hs1.erase( hs1_cIter );

   hs1_cIter = hs1.begin( );
   cout << "The first element of hs1 is now " << *hs1_cIter << endl;
}

The first element of hs1 is 1
The first element of hs1 is now 2

hash_set::cbegin

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

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

const_iterator cbegin() const;

Valor de retorno

Um iterador bidirecional const endereçando o primeiro elemento no hash_set ou o local que sucede um vazio hash_set.

Observações

Com o valor de retorno de cbegin, os hash_set elementos no objeto não podem ser modificados.

Exemplo

// hash_set_cbegin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_cIter = hs1.cbegin( );
   cout << "The first element of hs1 is " << *hs1_cIter << endl;
}

The first element of hs1 is 1

hash_set::cend

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Retorna um iterador const que aborda o local que sucede o último elemento em um hash_set.

const_iterator cend() const;

Valor de retorno

Um iterador bidirecional const que aborda o local que sucede o último elemento em um hash_set. Se o hash_set estiver vazio, então hash_set::cend == hash_set::begin.

Observações

cend é usado para testar se um iterador chegou ao final de sua hash_set. O valor retornado por cend não deve ser desreferenciado.

Exemplo

// hash_set_cend.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_cIter = hs1.cend( );
   hs1_cIter--;
   cout << "The last element of hs1 is " << *hs1_cIter << endl;
}

The last element of hs1 is 3

hash_set::limpar

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Apaga todos os elementos de um hash_set.

void clear();

Exemplo

// hash_set_clear.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

   hs1.insert( 1 );
   hs1.insert( 2 );

   cout << "The size of the hash_set is initially " << hs1.size( )
        << "." << endl;

   hs1.clear( );
   cout << "The size of the hash_set after clearing is "
        << hs1.size( ) << "." << endl;
}

The size of the hash_set is initially 2.
The size of the hash_set after clearing is 0.

hash_set::const_iterator

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo que fornece um iterador bidirecional que pode ler um const elemento no hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_iterator const_iterator;

Observações

Um tipo const_iterator não pode ser usado para modificar o valor de um elemento.

Exemplo

Consulte o exemplo para begin para obter um exemplo que usa const_iterator.

hash_set::const_pointer

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo que fornece um ponteiro para um const elemento em um hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_pointer const_pointer;

Observações

Um tipo const_pointer não pode ser usado para modificar o valor de um elemento.

Na maioria dos casos, um const_iterator deve ser usado para acessar os elementos em um const objeto hash_set.

hash_set::const_reference

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo que fornece uma referência a um const elemento armazenado em um hash_set para ler e executar const operações.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reference const_reference;

Exemplo

// hash_set_const_ref.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

   hs1.insert( 10 );
   hs1.insert( 20 );

   // Declare and initialize a const_reference &Ref1
   // to the 1st element
   const int &Ref1 = *hs1.begin( );

   cout << "The first element in the hash_set is "
        << Ref1 << "." << endl;

   // The following line would cause an error because the
   // const_reference cannot be used to modify the hash_set
   // Ref1 = Ref1 + 5;
}

The first element in the hash_set is 10.

hash_set::const_reverse_iterator

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo que fornece um iterador bidirecional que pode ler qualquer const elemento no hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reverse_iterator const_reverse_iterator;

Observações

Um tipo const_reverse_iterator não pode modificar o valor de um elemento e é usado para iterar através do hash_set em sentido inverso.

Exemplo

Veja o exemplo de rend para obter um exemplo de como declarar e usar o const_reverse_iterator

hash_set::contagem

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Retorna o número de elementos em um hash_set cuja chave corresponde a uma chave especificada por parâmetro.

size_type count(const Key& key) const;

Parâmetros

chave
A chave dos elementos a combinar a partir do hash_set.

Valor de retorno

1 se o hash_set contiver um elemento cuja chave de classificação corresponda à chave de parâmetro.

0 se o hash_set não contiver um elemento com uma chave correspondente.

Observações

A função de membro retorna o número de elementos no seguinte intervalo:

[ lower_bound(chave), upper_bound(chave) ).

Exemplo

O exemplo a seguir demonstra o uso da função de membro hash_set::count.

// hash_set_count.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_set<int> hs1;
    hash_set<int>::size_type i;

    hs1.insert(1);
    hs1.insert(1);

    // Keys must be unique in hash_set, so duplicates are ignored.
    i = hs1.count(1);
    cout << "The number of elements in hs1 with a sort key of 1 is: "
         << i << "." << endl;

    i = hs1.count(2);
    cout << "The number of elements in hs1 with a sort key of 2 is: "
         << i << "." << endl;
}

The number of elements in hs1 with a sort key of 1 is: 1.
The number of elements in hs1 with a sort key of 2 is: 0.

hash_set::crbegin

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Retorna um iterador const endereçando o primeiro elemento em um hash_set invertido.

const_reverse_iterator crbegin() const;

Valor de retorno

Um iterador bidirecional reverso const abordando o primeiro elemento em um hash_set reverso ou abordando o que havia sido o último elemento no não reverso hash_set.

Observações

crbegin é usado com uma hash_set invertida, assim como hash_set::begin é usado com uma hash_set.

Com o valor de retorno de crbegin, o hash_set objeto não pode ser modificado.

crbegin pode ser usado para iterar através de um hash_set para trás.

Exemplo

// hash_set_crbegin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::const_reverse_iterator hs1_crIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_crIter = hs1.crbegin( );
   cout << "The first element in the reversed hash_set is "
        << *hs1_crIter << "." << endl;
}

The first element in the reversed hash_set is 30.

hash_set::crend

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Retorna um iterador const que aborda o local que sucede o último elemento em um hash_set invertido.

const_reverse_iterator crend() const;

Valor de retorno

Um iterador bidirecional reverso const que aborda o local sucedendo o último elemento em um hash_set reverso (o local que precedeu o primeiro elemento no não reverso hash_set).

Observações

crend é usado com um reverso hash_set assim como hash_set::end é usado com um hash_setarquivo .

Com o valor de retorno de crend, o hash_set objeto não pode ser modificado.

crend pode ser usado para testar se um iterador reverso chegou ao final de sua hash_set.

Exemplo

// hash_set_crend.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::const_reverse_iterator hs1_crIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_crIter = hs1.crend( );
   hs1_crIter--;
   cout << "The last element in the reversed hash_set is "
        << *hs1_crIter << "." << endl;
}

The last element in the reversed hash_set is 10.

hash_set::d ifference_type

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo de inteiro assinado que pode ser usado para representar o número de elementos de um hash_set em um intervalo entre elementos apontados por iteradores.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::difference_type difference_type;

Observações

O difference_type é o tipo retornado ao subtrair ou incrementar através de iteradores do contêiner. O difference_type é normalmente usado para representar o número de elementos no intervalo [ first, last) entre os iteradores first e last, inclui o elemento apontado por first e o intervalo de elementos até, mas não incluindo, o elemento apontado por last.

Observe que, embora difference_type esteja disponível para todos os iteradores que satisfazem os requisitos de um iterador de entrada, que inclui a classe de iteradores bidirecionais suportados por contêineres reversíveis, como set, a subtração entre iteradores só é suportada por iteradores de acesso aleatório fornecidos por um contêiner de acesso aleatório, como vetor ou deque.

Exemplo

// hash_set_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_set>
#include <algorithm>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter, hs1_bIter, hs1_eIter;

   hs1.insert( 20 );
   hs1.insert( 10 );
   hs1.insert( 20 );   // Won't insert as hash_set elements are unique

   hs1_bIter = hs1.begin( );
   hs1_eIter = hs1.end( );

   hash_set <int>::difference_type   df_typ5, df_typ10, df_typ20;

   df_typ5 = count( hs1_bIter, hs1_eIter, 5 );
   df_typ10 = count( hs1_bIter, hs1_eIter, 10 );
   df_typ20 = count( hs1_bIter, hs1_eIter, 20 );

   // The keys, and hence the elements, of a hash_set are unique,
   // so there is at most one of a given value
   cout << "The number '5' occurs " << df_typ5
        << " times in hash_set hs1.\n";
   cout << "The number '10' occurs " << df_typ10
        << " times in hash_set hs1.\n";
   cout << "The number '20' occurs " << df_typ20
        << " times in hash_set hs1.\n";

   // Count the number of elements in a hash_set
   hash_set <int>::difference_type  df_count = 0;
   hs1_Iter = hs1.begin( );
   while ( hs1_Iter != hs1_eIter)
   {
      df_count++;
      hs1_Iter++;
   }

   cout << "The number of elements in the hash_set hs1 is: "
        << df_count << "." << endl;
}

The number '5' occurs 0 times in hash_set hs1.
The number '10' occurs 1 times in hash_set hs1.
The number '20' occurs 1 times in hash_set hs1.
The number of elements in the hash_set hs1 is: 2.

hash_set::emplace

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Insere um elemento construído no lugar em um hash_set.

template <class ValTy>
pair <iterator, bool>
emplace(
    ValTy&& val);

Parâmetros

Val
O valor de um elemento a ser inserido no hash_set a menos que o hash_set já contenha esse elemento ou, mais geralmente, um elemento cuja chave é ordenada equivalentemente.

Valor de retorno

A emplace função membro retorna um par cujo bool componente retorna true se uma inserção foi feita e false se o hash_set já continha um elemento cuja chave tinha um valor equivalente na ordenação e cujo componente iterador retorna o endereço onde um novo elemento foi inserido ou onde o elemento já estava localizado.

Exemplo

// hash_set_emplace.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set<string> hs3;
   string str1("a");

   hs3.emplace(move(str1));
   cout << "After the emplace insertion, hs3 contains "
      << *hs3.begin() << "." << endl;
}

After the emplace insertion, hs3 contains a.

hash_set::emplace_hint

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Insere um elemento construído no lugar em um hash_set.

template <class ValTy>
iterator emplace(
    const_iterator _Where,
    ValTy&& val);

Parâmetros

Val
O valor de um elemento a ser inserido no hash_set a menos que o hash_set já contenha esse elemento ou, mais geralmente, um elemento cuja chave é ordenada equivalentemente.

_Where
O lugar para começar a procurar o ponto correto de inserção. (A inserção pode ocorrer em tempo constante amortizado, em vez de tempo logarítmico, se o ponto de inserção seguir imediatamente _Where.)

Valor de retorno

A função membro hash_set::emplace retorna um iterador que aponta para a posição onde o novo elemento foi inserido no hash_set, ou onde o elemento existente com ordenação equivalente está localizado.

Observações

A inserção pode ocorrer em tempo constante amortizado, em vez de tempo logarítmico, se o ponto de inserção seguir imediatamente _Where.

Exemplo

// hash_set_emplace_hint.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set<string> hs3;
   string str1("a");

   hs3.insert(hs3.begin(), move(str1));
   cout << "After the emplace insertion, hs3 contains "
      << *hs3.begin() << "." << endl;
}

After the emplace insertion, hs3 contains a.

hash_set::vazio

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Testa se um hash_set está vazio.

bool empty() const;

Valor de retorno

true se o hash_set estiver vazio; false se o hash_set não estiver vazio.

Exemplo

// hash_set_empty.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1, hs2;
   hs1.insert ( 1 );

   if ( hs1.empty( ) )
      cout << "The hash_set hs1 is empty." << endl;
   else
      cout << "The hash_set hs1 is not empty." << endl;

   if ( hs2.empty( ) )
      cout << "The hash_set hs2 is empty." << endl;
   else
      cout << "The hash_set hs2 is not empty." << endl;
}

The hash_set hs1 is not empty.
The hash_set hs2 is empty.

hash_set::fim

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Retorna um iterador que aborda o local que sucede o último elemento em um hash_set.

const_iterator end() const;

iterator end();

Valor de retorno

Um iterador bidirecional que aborda o local que sucede o último elemento em um hash_set. Se o hash_set estiver vazio, então hash_set::end == hash_set::begin.

Observações

end é usado para testar se um iterador chegou ao final de sua hash_set. O valor retornado por end não deve ser desreferenciado.

Exemplo

// hash_set_end.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: iterator hs1_Iter;
   hash_set <int> :: const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_Iter = hs1.end( );
   hs1_Iter--;
   cout << "The last element of hs1 is " << *hs1_Iter << endl;

   hs1.erase( hs1_Iter );

   // The following 3 lines would err because the iterator is const:
   // hs1_cIter = hs1.end( );
   // hs1_cIter--;
   // hs1.erase( hs1_cIter );

   hs1_cIter = hs1.end( );
   hs1_cIter--;
   cout << "The last element of hs1 is now " << *hs1_cIter << endl;
}

The last element of hs1 is 3
The last element of hs1 is now 2

hash_set::equal_range

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Retorna um par de iteradores respectivamente para o primeiro elemento em um conjunto de hash com uma chave que é igual a uma chave especificada e para o primeiro elemento no conjunto de hash com uma chave que é maior do que a chave.

pair <const_iterator, const_iterator> equal_range (const Key& key) const;

pair <iterator, iterator> equal_range (const Key& key);

Parâmetros

chave
A chave de argumento a ser comparada com a chave de classificação de um elemento do hash_set que está sendo pesquisado.

Valor de retorno

Um par de iteradores onde o primeiro é o lower_bound da chave e o segundo é o upper_bound da chave.

Para acessar o primeiro iterador de um par pr retornado pela função membro, use pr. Primeiro, e para desreferenciar o iterador de limite inferior, use *(pr. primeiro). Para acessar o segundo iterador de um par pr retornado pela função de membro, use pr. segundo, e para desreferenciar o iterador de limite superior, use *(pr. segundo).

Exemplo

// hash_set_equal_range.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_set<int> IntHSet;
   IntHSet hs1;
   hash_set <int> :: const_iterator hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   pair <IntHSet::const_iterator, IntHSet::const_iterator> p1, p2;
   p1 = hs1.equal_range( 20 );

   cout << "The upper bound of the element with "
        << "a key of 20 in the hash_set hs1 is: "
        << *(p1.second) << "." << endl;

   cout << "The lower bound of the element with "
        << "a key of 20 in the hash_set hs1 is: "
        << *(p1.first) << "." << endl;

   // Compare the upper_bound called directly
   hs1_RcIter = hs1.upper_bound( 20 );
   cout << "A direct call of upper_bound( 20 ) gives "
        << *hs1_RcIter << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 20 )." << endl;

   p2 = hs1.equal_range( 40 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == hs1.end( ) ) && ( p2.second == hs1.end( ) ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key greater than or equal to 40." << endl;
   else
      cout << "The element of hash_set hs1 with a key >= 40 is: "
           << *(p1.first) << "." << endl;
}

The upper bound of the element with a key of 20 in the hash_set hs1 is: 30.
The lower bound of the element with a key of 20 in the hash_set hs1 is: 20.
A direct call of upper_bound( 20 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 20 ).
The hash_set hs1 doesn't have an element with a key greater than or equal to 40.

hash_set::apagar

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Remove um elemento ou um intervalo de elementos em um hash_set de posições especificadas ou remove elementos que correspondem a uma chave especificada.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Parâmetros

_Where
Posição do elemento a retirar da hash_set.

primeira
Posição do primeiro elemento retirado do hash_set.

último
Posição logo após o último elemento removido do hash_set.

chave
A chave dos elementos a serem removidos do hash_set.

Valor de retorno

Para as duas primeiras funções de membro, um iterador bidirecional que designa o primeiro elemento restante além de quaisquer elementos removidos, ou um ponteiro para o final do hash_set se tal elemento não existir. Para a função de terceiro membro, o número de elementos que foram removidos do hash_set.

Observações

As funções de membro nunca lançam uma exceção.

Exemplo

O exemplo a seguir demonstra o uso da função de membro hash_set::erase.

// hash_set_erase.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_set<int> hs1, hs2, hs3;
    hash_set<int>::iterator pIter, Iter1, Iter2;
    int i;
    hash_set<int>::size_type n;

    for (i = 1; i < 5; i++)
    {
        hs1.insert (i);
        hs2.insert (i * i);
        hs3.insert (i - 1);
    }

    // The 1st member function removes an element at a given position
    Iter1 = ++hs1.begin();
    hs1.erase(Iter1);

    cout << "After the 2nd element is deleted, the hash_set hs1 is:";
    for (pIter = hs1.begin(); pIter != hs1.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 2nd member function removes elements
    // in the range [ first,  last)
    Iter1 = ++hs2.begin();
    Iter2 = --hs2.end();
    hs2.erase(Iter1, Iter2);

    cout << "After the middle two elements are deleted, "
         << "the hash_set hs2 is:";
    for (pIter = hs2.begin(); pIter != hs2.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 3rd member function removes elements with a given  key
    n = hs3.erase(2);

    cout << "After the element with a key of 2 is deleted, "
         << "the hash_set hs3 is:";
    for (pIter = hs3.begin(); pIter != hs3.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 3rd member function returns the number of elements removed
    cout << "The number of elements removed from hs3 is: "
         << n << "." << endl;

    // The dereferenced iterator can also be used to specify a key
    Iter1 = ++hs3.begin();
    hs3.erase(Iter1);

    cout << "After another element (unique for hash_set) with a key "
         << endl;
    cout  << "equal to that of the 2nd element is deleted, "
          << "the hash_set hs3 is:";
    for (pIter = hs3.begin(); pIter != hs3.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;
}

After the 2nd element is deleted, the hash_set hs1 is: 1 3 4.
After the middle two elements are deleted, the hash_set hs2 is: 16 4.
After the element with a key of 2 is deleted, the hash_set hs3 is: 0 1 3.
The number of elements removed from hs3 is: 1.
After another element (unique for hash_set) with a key
equal to that of the 2nd element is deleted, the hash_set hs3 is: 0 3.

hash_set::encontrar

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Retorna um iterador abordando o local de um elemento em um hash_set que tem uma chave equivalente a uma chave especificada.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parâmetros

chave
A chave de argumento a ser correspondida pela chave de classificação de um elemento do hash_set que está sendo pesquisado.

Valor de retorno

Um iterator ou const_iterator que aborda o local de um elemento equivalente a uma chave especificada ou que aborda o local que sucede o último elemento no hash_set se nenhuma correspondência for encontrada para a chave.

Observações

A função de membro retorna um iterador que aborda um elemento no hash_set cuja chave de classificação é equivalent para a chave de argumento sob um predicado binário que induz uma ordenação baseada em uma relação de comparabilidade menor.

Se o valor de retorno de find for atribuído a um const_iterator, o objeto hash_set não poderá ser modificado. Se o valor de retorno de find for atribuído a um iterator, o objeto hash_set poderá ser modificado.

Exemplo

// hash_set_find.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_RcIter = hs1.find( 20 );
   cout << "The element of hash_set hs1 with a key of 20 is: "
        << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.find( 40 );

   // If no match is found for the key, end( ) is returned
   if ( hs1_RcIter == hs1.end( ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of hash_set hs1 with a key of 40 is: "
           << *hs1_RcIter << "." << endl;

   // The element at a specific location in the hash_set can be found
   // by using a dereferenced iterator addressing the location
   hs1_AcIter = hs1.end( );
   hs1_AcIter--;
   hs1_RcIter = hs1.find( *hs1_AcIter );
   cout << "The element of hs1 with a key matching "
        << "that of the last element is: "
        << *hs1_RcIter << "." << endl;
}

The element of hash_set hs1 with a key of 20 is: 20.
The hash_set hs1 doesn't have an element with a key of 40.
The element of hs1 with a key matching that of the last element is: 30.

hash_set::get_allocator

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Retorna uma cópia do objeto alocador usado para construir o hash_set.

Allocator get_allocator() const;

Valor de retorno

O alocador usado pelo hash_set para gerenciar a memória, que é o parâmetro de modelo Allocator.

Para obter mais informações sobre o Allocator, consulte a seção Comentários do tópico Classe hash_set .

Observações

Os alocadores para a classe hash_set especificam como a classe gerencia o armazenamento. Os alocadores padrão fornecidos com classes de contêiner C++ Standard Library são suficientes para a maioria das necessidades de programação. Escrever e usar sua própria classe de alocador é um tópico C++ avançado.

Exemplo

// hash_set_get_allocator.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   // The following lines declare objects
   // that use the default allocator.
   hash_set <int, hash_compare <int, less<int> > > hs1;
   hash_set <int,  hash_compare <int, greater<int> > > hs2;
   hash_set <double, hash_compare <double,
      less<double> >, allocator<double> > hs3;

   hash_set <int, hash_compare <int,
      greater<int> > >::allocator_type hs2_Alloc;
   hash_set <double>::allocator_type hs3_Alloc;
   hs2_Alloc = hs2.get_allocator( );

   cout << "The number of integers that can be allocated"
        << endl << "before free memory is exhausted: "
        << hs1.max_size( ) << "." << endl;

   cout << "The number of doubles that can be allocated"
        << endl << "before free memory is exhausted: "
        << hs3.max_size( ) <<  "." << endl;

   // The following lines create a hash_set hs4
   // with the allocator of hash_set hs1.
   hash_set <int>::allocator_type hs4_Alloc;
   hash_set <int> hs4;
   hs4_Alloc = hs2.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated by the other
   if( hs2_Alloc == hs4_Alloc )
   {
      cout << "The allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "The allocators are not interchangeable."
           << endl;
   }
}

hash_set::hash_set

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Constrói um hash_set que está vazio ou que é uma cópia de todo ou parte de algum outro hash_set.

hash_set();

explicit hash_set(
    const Traits& Comp);

hash_set(
    const Traits& Comp,
    const Allocator& Al);

hash_set(
    const hash_set<Key, Traits, Allocator>& Right);

hash_set(
    hash_set&& Right);

hash_set(
    initializer_list<Type> IList);

hash_set(
    initializer_list<Type> IList,
    const Compare& Comp);

hash_set(
    initializer_list<value_type> IList,
    const Compare& Comp,
    const Allocator& Al);

template <class InputIterator>
hash_set(
    InputIterator First,
    InputIterator Last);

template <class InputIterator>
hash_set(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp);

template <class InputIterator>
hash_set(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp,
    const Allocator& Al);

Parâmetros

Al
A classe do alocador de armazenamento a ser usada para esse hash_set objeto, cujo padrão é Allocator.

Comp
A função de comparação do tipo const Traits usada para ordenar os elementos no hash_set, que assume como hash_comparepadrão .

Direito
O hash_set do qual o hash_set construído deve ser uma cópia.

Primeira
A posição do primeiro elemento na gama de elementos a serem copiados.

Última
A posição do primeiro elemento além da gama de elementos a serem copiados.

Observações

Todos os construtores armazenam um tipo de objeto alocador que gerencia o armazenamento de memória para o hash_set e que pode ser retornado posteriormente chamando hash_set::get_allocator. O parâmetro allocator é frequentemente omitido nas declarações de classe e macros de pré-processamento usadas para substituir alocadores alternativos.

Todos os construtores inicializam seus hash_sets.

Todos os construtores armazenam um objeto de função do tipo Traits que é usado para estabelecer uma ordem entre as chaves do hash_set e que pode ser retornado posteriormente chamando hash_set::key_comp. Para obter mais informações, Traits consulte o tópico Classe hash_set .

O primeiro construtor cria uma inicial hash_set vazia O segundo especifica o tipo de função de comparação (Comp) a ser usado no estabelecimento da ordem dos elementos, e o terceiro especifica explicitamente o tipo de alocador (Al) a ser usado. A palavra-chave explicit suprime certos tipos de conversão automática de tipos.

O quarto e quinto construtores especificam uma cópia do hash_setRight.

Os últimos sexto, sétimo e oitavo construtores usam um initializer_list para os elementos.

Os últimos construtores copiam o intervalo [ First, Last) de a hash_set com crescente explicitação na especificação do tipo de função de comparação de classe Traços e alocador.

O oitavo construtor move o hash_setRight.

A ordem real dos elementos em um hash_set contêiner depende da função hash, da função de ordenação e do tamanho atual da tabela de hash e não pode, em geral, ser prevista como poderia com o contêiner definido, onde foi determinada apenas pela função de ordenação.

hash_set::inserir

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

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

pair<iterator, bool> insert(
    const value_type& Val);

iterator insert(
    iterator Where,
    const value_type& Val);

void insert(
    initializer_list<value_type> IList)
template <class InputIterator>
void insert(
    InputIterator First,
    InputIterator Last);

Parâmetros

Val
O valor de um elemento a ser inserido hash_set no a menos que o hash_set já contenha esse elemento ou, mais geralmente, um elemento cuja chave é ordenada equivalentemente.

Onde
O lugar para começar a procurar o ponto correto de inserção. (A inserção pode ocorrer em tempo constante amortizado, em vez de tempo logarítmico, se o ponto de inserção se seguir _Whereimediatamente.)

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

Última
A posição logo após o último elemento a ser copiado de um hash_setarquivo .

IList
O initializer_list do qual copiar os elementos.

Valor de retorno

A primeira insert função de membro retorna um par cujo bool componente retorna true se uma inserção foi feita e false se o hash_set já continha um elemento cuja chave tinha um valor equivalente na ordenação e cujo componente iterador retorna o endereço onde um novo elemento foi inserido ou onde o elemento já estava localizado.

Para acessar o componente iterador de um par pr retornado por essa função de membro, use pr.first e para desreferenciar ele, use *(pr.first). Para acessar o bool componente de um par pr retornado por essa função de membro, use pr.second, e para desreferenciar ele, use *(pr.second).

A segunda insert função de membro retorna um iterador que aponta para a posição onde o novo elemento foi inserido no hash_set.

Observações

A função de terceiro membro insere os elementos em um initializer_list.

A função de terceiro membro insere a sequência de valores de elementos em um hash_set correspondente a cada elemento endereçado por um iterador de no intervalo [ First, Last) de um especificado hash_set.

hash_set::iterador

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo que fornece um iterador bidirecional que pode ler ou modificar qualquer elemento em um hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::iterator iterator;

Observações

Um tipo iterator pode ser usado para modificar o valor de um elemento.

Exemplo

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

hash_set::key_comp

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Recupera uma cópia do objeto de traços de hash usado para hash e ordenar valores de chave de elemento em um hash_set.

key_compare key_comp() const;

Valor de retorno

Retorna o objeto de função que um hash_set usa para ordenar seus elementos, que é o parâmetro de modelo Traits.

Para obter mais informações sobre Traits , consulte o tópico hash_set Class .

Observações

O objeto armazenado define a função de membro:

bool operator( const Key& _xVal, const Key& _yVal );

que retorna true se _xVal precede e não é igual a _yVal na ordem de classificação.

Observe que key_compare e value_compare são sinônimos para o parâmetro de modelo Traits. Ambos os tipos são fornecidos para as classes hash_set e hash_multiset, onde são idênticos, para compatibilidade com as classes hash_map e hash_multimap, onde são distintos.

Exemplo

// hash_set_key_comp.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_set <int, hash_compare < int, less<int> > >hs1;
   hash_set<int, hash_compare < int, less<int> > >::key_compare kc1
          = hs1.key_comp( ) ;
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true, "
           << "where kc1 is the function object of hs1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of hs1."
        << endl;
   }

   hash_set <int, hash_compare < int, greater<int> > > hs2;
   hash_set<int, hash_compare < int, greater<int> > >::key_compare
         kc2 = hs2.key_comp( ) ;
   bool result2 = kc2( 2, 3 ) ;
   if(result2 == true)
   {
      cout << "kc2( 2,3 ) returns value of true, "
           << "where kc2 is the function object of hs2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of hs2."
           << endl;
   }
}

hash_set::key_compare

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo que fornece um objeto de função que pode comparar duas chaves de classificação para determinar a ordem relativa de dois elementos no hash_set.

typedef Traits key_compare;

Observações

key_compare é um sinônimo para o parâmetro de modelo Traits.

Para obter mais informações sobre Traits , consulte o tópico hash_set Class .

Observe que ambos e key_comparevalue_compare são sinônimos para o parâmetro de modelo Traits. Ambos os tipos são fornecidos para as classes set e multiset, onde são idênticos, para compatibilidade com as classes map e multimap, onde são distintos.

Exemplo

Veja o exemplo para key_comp para um exemplo de como declarar e usar key_compare.

hash_set::key_type

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo que descreve um objeto armazenado como um elemento de um hash_set em sua capacidade como chave de classificação.

typedef Key key_type;

Observações

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

Para obter mais informações sobre Key, consulte a seção Comments do tópico hash_set Class .

Observe que ambos e key_type são sinônimos para o parâmetro de modelo Key. Ambos os tipos são fornecidos para as classes hash_set e hash_multiset, onde são idênticos, para compatibilidade com as classes hash_map e hash_multimap, onde são distintos.

Exemplo

Veja o exemplo para value_type para obter um exemplo de como declarar e usar key_typeo .

hash_set::lower_bound

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Retorna um iterador para o primeiro elemento em um hash_set com uma chave que é igual ou maior do que uma chave especificada.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parâmetros

chave
A chave de argumento a ser comparada com a chave de classificação de um elemento do hash_set que está sendo pesquisado.

Valor de retorno

Um iterator ou const_iterator que aborda o local de um elemento em um hash_set com uma chave igual ou maior que a chave de argumento ou que aborda o local que sucede o último elemento no hash_set se nenhuma correspondência for encontrada para a chave.

Exemplo

// hash_set_lower_bound.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_RcIter = hs1.lower_bound( 20 );
   cout << "The element of hash_set hs1 with a key of 20 is: "
        << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.lower_bound( 40 );

   // If no match is found for the key, end( ) is returned
   if ( hs1_RcIter == hs1.end( ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of hash_set hs1 with a key of 40 is: "
           << *hs1_RcIter << "." << endl;

   // An element at a specific location in the hash_set can be found
   // by using a dereferenced iterator that addresses the location
   hs1_AcIter = hs1.end( );
   hs1_AcIter--;
   hs1_RcIter = hs1.lower_bound( *hs1_AcIter );
   cout << "The element of hs1 with a key matching "
        << "that of the last element is: "
        << *hs1_RcIter << "." << endl;
}

The element of hash_set hs1 with a key of 20 is: 20.
The hash_set hs1 doesn't have an element with a key of 40.
The element of hs1 with a key matching that of the last element is: 30.

hash_set::max_size

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Devolve o comprimento máximo do hash_set.

size_type max_size() const;

Valor de retorno

O comprimento máximo possível do hash_set.

Exemplo

// hash_set_max_size.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::size_type i;

   i = hs1.max_size( );
   cout << "The maximum possible length "
        << "of the hash_set is " << i << "." << endl;
}

hash_set::operador=

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Substitui os elementos do hash_set por uma cópia de outro hash_set.

hash_set& operator=(const hash_set& right);

hash_set& operator=(hash_set&& right);

Parâmetros

direito
O hash_set sendo copiado para o hash_set.

Observações

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

Exemplo

// hash_set_operator_as.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

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

   v1.insert(10);

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

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

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

hash_set::p ointer

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo que fornece um ponteiro para um elemento em um hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::pointer pointer;

Observações

Um tipo pointer pode ser usado para modificar o valor de um elemento.

Na maioria dos casos, um iterador deve ser usado para acessar os elementos em um objeto hash_set.

hash_set::rbegin

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Retorna um iterador endereçando o primeiro elemento em um hash_set invertido.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor de retorno

Um iterador bidirecional reverso abordando o primeiro elemento em uma hash_set invertida ou abordando o que havia sido o último elemento na hash_set não invertida.

Observações

rbegin é usado com uma hash_set invertida, assim como begin é usado com uma hash_set.

Se o valor de retorno de rbegin for atribuído a um const_reverse_iterator, o objeto hash_set não poderá ser modificado. Se o valor de retorno de rbegin for atribuído a um reverse_iterator, o objeto hash_set poderá ser modificado.

rbegin pode ser usado para iterar através de um hash_set para trás.

Exemplo

// hash_set_rbegin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;
   hash_set <int>::reverse_iterator hs1_rIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_rIter = hs1.rbegin( );
   cout << "The first element in the reversed hash_set is "
        << *hs1_rIter << "." << endl;

   // begin can be used to start an iteration
   // through a hash_set in a forward order
   cout << "The hash_set is: ";
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( );
         hs1_Iter++ )
      cout << *hs1_Iter << " ";
   cout << endl;

   // rbegin can be used to start an iteration
   // through a hash_set in a reverse order
   cout << "The reversed hash_set is: ";
   for ( hs1_rIter = hs1.rbegin( ) ; hs1_rIter != hs1.rend( );
         hs1_rIter++ )
      cout << *hs1_rIter << " ";
   cout << endl;

   // A hash_set element can be erased by dereferencing to its key
   hs1_rIter = hs1.rbegin( );
   hs1.erase ( *hs1_rIter );

   hs1_rIter = hs1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed hash_set is "<< *hs1_rIter << "."
        << endl;
}

The first element in the reversed hash_set is 30.
The hash_set is: 10 20 30
The reversed hash_set is: 30 20 10
After the erasure, the first element in the reversed hash_set is 20.

hash_set::referência

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo que fornece uma referência a um elemento armazenado em um hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::reference reference;

Exemplo

// hash_set_reference.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

   hs1.insert( 10 );
   hs1.insert( 20 );

   // Declare and initialize a reference &Ref1 to the 1st element
   int &Ref1 = *hs1.begin( );

   cout << "The first element in the hash_set is "
        << Ref1 << "." << endl;

   // The value of the 1st element of the hash_set can be changed
   // by operating on its (non-const) reference
   Ref1 = Ref1 + 5;

   cout << "The first element in the hash_set is now "
        << *hs1.begin() << "." << endl;
}

The first element in the hash_set is 10.
The first element in the hash_set is now 15.

hash_set::rend

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Retorna um iterador que aborda o local que sucede o último elemento em um hash_set invertido.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valor de retorno

Um iterador bidirecional reverso que aborda o local que sucede o último elemento em um hash_set reverso (o local que precedeu o primeiro elemento no hash_set não invertido).

Observações

rend é usado com uma hash_set invertida, assim como a extremidade é usada com uma hash_set.

Se o valor de retorno de rend for atribuído a um const_reverse_iterator, o objeto hash_set não poderá ser modificado. Se o valor de retorno de rend for atribuído a um reverse_iterator, o objeto hash_set poderá ser modificado. O valor retornado por rend não deve ser desreferenciado.

rend pode ser usado para testar se um iterador reverso chegou ao final de sua hash_set.

Exemplo

// hash_set_rend.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;
   hash_set <int>::reverse_iterator hs1_rIter;
   hash_set <int>::const_reverse_iterator hs1_crIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   cout << "The last element in the reversed hash_set is "
        << *hs1_rIter << "." << endl;

   // end can be used to terminate an iteration
   // through a hash_set in a forward order
   cout << "The hash_set is: ";
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( );
         hs1_Iter++ )
      cout << *hs1_Iter << " ";
   cout << "." << endl;

   // rend can be used to terminate an iteration
   // through a hash_set in a reverse order
   cout << "The reversed hash_set is: ";
   for ( hs1_rIter = hs1.rbegin( ) ; hs1_rIter != hs1.rend( );
         hs1_rIter++ )
      cout << *hs1_rIter << " ";
   cout << "." << endl;

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   hs1.erase ( *hs1_rIter );

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   cout << "After the erasure, the last element in the "
        << "reversed hash_set is " << *hs1_rIter << "."
        << endl;
}

The last element in the reversed hash_set is 10.
The hash_set is: 10 20 30 .
The reversed hash_set is: 30 20 10 .
After the erasure, the last element in the reversed hash_set is 20.

hash_set::reverse_iterator

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo que fornece um iterador bidirecional que pode ler ou modificar um elemento em uma hash_set invertida.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::reverse_iterator reverse_iterator;

Observações

Um tipo reverse_iterator é usado para iterar através do hash_set em sentido inverso.

Exemplo

Veja o exemplo de rbegin para obter um exemplo de como declarar e usar reverse_iterator.

hash_set::tamanho

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Retorna o número de elementos no hash_set.

size_type size() const;

Valor de retorno

O comprimento atual do hash_set.

Exemplo

// hash_set_size.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: size_type i;

   hs1.insert( 1 );
   i = hs1.size( );
   cout << "The hash_set length is " << i << "." << endl;

   hs1.insert( 2 );
   i = hs1.size( );
   cout << "The hash_set length is now " << i << "." << endl;
}

The hash_set length is 1.
The hash_set length is now 2.

hash_set::size_type

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo de inteiro não assinado que pode representar o número de elementos em um hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::size_type size_type;

Exemplo

Veja o exemplo de tamanho para um exemplo de como declarar e usar size_type

hash_set::swap

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Troca os elementos de duas hash_sets.

void swap(hash_set& right);

Parâmetros

direito
O argumento hash_set fornecer os elementos a serem trocados com o hash_set de destino.

Observações

A função de membro não invalida referências, ponteiros ou iteradores que designam elementos nos dois hash_sets cujos elementos estão sendo trocados.

Exemplo

// hash_set_swap.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1, hs2, hs3;
   hash_set <int>::iterator hs1_Iter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );
   hs2.insert( 100 );
   hs2.insert( 200 );
   hs3.insert( 300 );

   cout << "The original hash_set hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout   << "." << endl;

   // This is the member function version of swap
   hs1.swap( hs2 );

   cout << "After swapping with hs2, list hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hs1, hs3 );

   cout << "After swapping with hs3, list hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout   << "." << endl;
}

The original hash_set hs1 is: 10 20 30.
After swapping with hs2, list hs1 is: 200 100.
After swapping with hs3, list hs1 is: 300.

hash_set::upper_bound

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Retorna um iterador para o primeiro elemento em um hash_set que com uma chave que é maior do que uma chave especificada.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parâmetros

chave
A chave de argumento a ser comparada com a chave de classificação de um elemento do hash_set que está sendo pesquisado.

Valor de retorno

Um iterator ou const_iterator que aborda o local de um elemento em um hash_set com uma chave igual ou maior que a chave de argumento, ou que aborda o local que sucede o último elemento no hash_set se nenhuma correspondência for encontrada para a chave.

Exemplo

// hash_set_upper_bound.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_RcIter = hs1.upper_bound( 20 );
   cout << "The first element of hash_set hs1 with a key greater "
        << "than 20 is: " << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.upper_bound( 30 );

   // If no match is found for the key, end( ) is returned
   if ( hs1_RcIter == hs1.end( ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key greater than 30." << endl;
   else
      cout << "The element of hash_set hs1 with a key > 40 is: "
           << *hs1_RcIter << "." << endl;

   // An element at a specific location in the hash_set can be found
   // by using a dereferenced iterator addressing the location
   hs1_AcIter = hs1.begin( );
   hs1_RcIter = hs1.upper_bound( *hs1_AcIter );
   cout << "The first element of hs1 with a key greater than "
        << endl << "that of the initial element of hs1 is: "
        << *hs1_RcIter << "." << endl;
}

The first element of hash_set hs1 with a key greater than 20 is: 30.
The hash_set hs1 doesn't have an element with a key greater than 30.
The first element of hs1 with a key greater than
that of the initial element of hs1 is: 20.

hash_set::value_comp

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Recupera uma cópia do objeto de comparação usado para ordenar valores de elementos em um hash_set.

value_compare value_comp() const;

Valor de retorno

Retorna o objeto de função que um hash_set usa para ordenar seus elementos, que é o parâmetro de modelo Compare.

Para obter mais informações sobre Comparar, consulte a seção Comentários do tópico Classe hash_set .

Observações

O objeto armazenado define a função de membro:

bool operator( const Key& _xVal, const Key& _yVal );

que retorna true se _xVal precede e não é igual a _yVal na ordem de classificação.

Observe que value_compare e key_compare são sinônimos para o parâmetro de modelo Compare. Ambos os tipos são fornecidos para as classes hash_set e hash_multiset, onde são idênticos, para compatibilidade com as classes hash_map e hash_multimap, onde são distintos.

Exemplo

// hash_set_value_comp.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_set <int, hash_compare < int, less<int> > > hs1;
   hash_set <int, hash_compare < int, less<int> >  >::value_compare
      vc1 = hs1.value_comp( );
   bool result1 = vc1( 2, 3 );
   if( result1 == true )
   {
      cout << "vc1( 2,3 ) returns value of true, "
           << "where vc1 is the function object of hs1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of hs1."
           << endl;
   }

   hash_set <int, hash_compare < int, greater<int> > > hs2;
   hash_set<int, hash_compare < int, greater<int> > >::value_compare
      vc2 = hs2.value_comp( );
   bool result2 = vc2( 2, 3 );
   if( result2 == true )
   {
      cout << "vc2( 2,3 ) returns value of true, "
           << "where vc2 is the function object of hs2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of hs2."
           << endl;
   }
}

hash_set::value_compare

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo que fornece dois objetos de função, um predicado binário de comparação de classe que pode comparar dois valores de elemento de um hash_set para determinar sua ordem relativa e um predicado unário que hashes os elementos.

typedef key_compare value_compare;

Observações

value_compare é um sinônimo para o parâmetro de modelo Traits.

Para obter mais informações sobre Traits , consulte o tópico hash_set Class .

Observe que ambos key_compare e value_compare são sinônimos para o parâmetro de modelo Traits. Ambos os tipos são fornecidos para as classes hash_set e hash_multiset, onde são idênticos, para compatibilidade com as classes hash_map e hash_multimap, onde são distintos.

Exemplo

Veja o exemplo para value_comp para um exemplo de como declarar e usar value_compare.

hash_set::value_type

Observação

Esta API está obsoleta. A alternativa é unordered_set Classe.

Um tipo que descreve um objeto armazenado como um elemento de um hash_set em sua capacidade como um valor.

typedef Key value_type;

Exemplo

// hash_set_value_type.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;

   hash_set <int> :: value_type hsvt_Int;   // Declare value_type
   hsvt_Int = 10;             // Initialize value_type

   hash_set <int> :: key_type hskt_Int;   // Declare key_type
   hskt_Int = 20;             // Initialize key_type

   hs1.insert( hsvt_Int );         // Insert value into hs1
   hs1.insert( hskt_Int );         // Insert key into hs1

   // A hash_set accepts key_types or value_types as elements
   cout << "The hash_set has elements:";
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( ); hs1_Iter++)
      cout << " " << *hs1_Iter;
   cout << "." << endl;
}

The hash_set has elements: 10 20.

Ver também

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

Feedback

Esta página foi útil?

Last updated on 2025-11-07

Partilhar via

hash_set Classe

Sintaxe

Parâmetros

Observações

Construtores

Typedefs (definições de tipos)

Funções de membro

Operadores

Requerimentos

hash_set::allocator_type

Observações

Exemplo

hash_set::começar

Valor de retorno

Observações

Exemplo

hash_set::cbegin

Valor de retorno

Observações

Exemplo

hash_set::cend

Valor de retorno

Observações

Exemplo

hash_set::limpar

Exemplo

hash_set::const_iterator

Observações

Exemplo

hash_set::const_pointer

Observações

hash_set::const_reference

Exemplo

hash_set::const_reverse_iterator

Observações

Exemplo

hash_set::contagem

Parâmetros

Valor de retorno

Observações

Exemplo

hash_set::crbegin

Valor de retorno

Observações

Exemplo

hash_set::crend

Valor de retorno

Observações

Exemplo

hash_set::d ifference_type

Observações

Exemplo

hash_set::emplace

Parâmetros

Valor de retorno

Exemplo

hash_set::emplace_hint

Parâmetros

Valor de retorno

Observações

Exemplo

hash_set::vazio

Valor de retorno

Exemplo

hash_set::fim

Valor de retorno

Observações

Exemplo

hash_set::equal_range

Parâmetros

Valor de retorno

Exemplo

hash_set::apagar

Parâmetros

Valor de retorno

Observações

Exemplo

hash_set::encontrar

Parâmetros