Classe `set`

Artigo
10/12/2023

A classe de contêiner da Biblioteca Padrão C++ set, que é usada para armazenar e recuperar dados de uma coleção. Os valores dos elementos em set são exclusivos e funcionam como os valores de chave, de acordo com os quais os dados são automaticamente ordenados. O valor de um elemento em um set não pode ser alterado diretamente. Em vez disso, você deve excluir valores antigos e inserir elementos com novos valores.

Sintaxe

template <class Key,
    class Traits=less<Key>,
    class Allocator=allocator<Key>>
class set

Parâmetros

Key
O tipo de dados do elemento a ser armazenado no conjunto.

Traits
O tipo que fornece um objeto de função que pode comparar dois valores de elemento como chaves de classificação para determinar sua ordem relativa no conjunto. Esse argumento é opcional e o predicado binário less <Key> é o valor padrão.

No C++ 14, você pode habilitar a pesquisa heterogênea ao especificar o predicado std::less<> ou o std::greater<>, que não tem nenhum parâmetro de tipo. Confira Pesquisa Heterogênea em Contêineres Associativos para saber mais.

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

Comentários

A Biblioteca Padrão C++ é:

Um contêiner associativo, que é um contêiner de tamanho variável que oferece suporte à recuperação eficiente dos valores de elemento com base em um valor de chave associado. Além disso, ele é contêiner associativo simples, pois seus valores de elemento são seus valores de chave.
Reversível, pois fornece um iterador bidirecional para acessar seus elementos.
Classificada, pois seus elementos são ordenados por valores de chave no contêiner, de acordo com uma função de comparação especificada.
Exclusivo no sentido de que cada um de seus elementos deve ter uma chave exclusiva. Uma vez que o conjunto também é um contêiner associativo simples, seus elementos também são exclusivos.

Um conjunto também é descrito como um modelo de classe, pois a funcionalidade fornecida por ele é genérica e independente do tipo de dados específico contido como elementos. O tipo de dados a ser usado é especificado como um parâmetro no modelo de classe juntamente com a função de comparação e o alocador.

A escolha do tipo de contêiner deve se basear, de modo geral, no tipo de pesquisa e inserção exigido pelo aplicativo. Os contêineres associativos são otimizados para as operações de pesquisa, inserção e remoção. As funções de membro que dão suporte explicitamente a essas operações são eficientes, realizando-as em um tempo que está na média proporcional para o logaritmo do número de elementos no contêiner. Inserir elementos não invalida iteradores e remover elementos invalida apenas os iteradores que apontavam os elementos removidos.

O conjunto deve ser o contêiner associativo escolhido quando as condições que associam os valores às respectivas chaves forem atendidas pelo aplicativo. Os elementos de um conjunto são exclusivos e servem como suas próprias chaves de classificação. Um modelo para esse tipo de estrutura é uma lista ordenada de palavras, por exemplo, na qual as palavras podem ocorrer apenas uma vez. Se não foram permitidas as várias ocorrências das palavras, um multiset seria a estrutura de contêiner apropriada. Se for preciso anexar valores a uma lista de palavras-chave exclusivas, um mapa será uma estrutura apropriada para conter esses dados. Se, em vez disso, as chaves não forem exclusivas, um multimapa será o contêiner ideal.

O conjunto ordena a sequência que controla chamando um objeto de função armazenado do tipo key_compare. Esse objeto armazenado é uma função de comparação que pode ser acessada chamando a função de membro key_comp. De modo geral, os elementos precisam ser simplesmente menores que os comparáveis para estabelecer essa ordem, de modo que, considerando dois elementos quaisquer, pode ser determinado que, ou eles são equivalentes (no sentido de que nenhum deles é menor que o outro), ou que um é menor que o outro. Isso resulta em uma ordenação entre os elementos não equivalentes. Fazendo uma observação mais técnica, a função de comparação é um predicado binário que induz a uma ordenação fraca restrita 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 retornado de true ou false. Uma ordenação imposta a um conjunto é uma ordenação fraca estrita se o predicado binário for irreflexivo, antissimétrico e transitivo e se a equivalência for 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 as chaves substituir essa equivalência, a ordenação será total (no sentido de que todos os elementos serão ordenados um em relação ao outro) e as chaves correspondentes não poderão ser diferenciadas uma da outra.

O iterador fornecido pela classe é um iterador bidirecional, mas as funções de membro de classe insert e set têm versões que usam como parâmetros de modelo um iterador de entrada mais fraco, cujos requisitos de funcionalidade são mais minimalistas do que aqueles assegurados pela classe de iteradores bidirecionais. Os conceitos de iterador diferente 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 funcionam com eles devem limitar suas suposições para os requisitos fornecidos por esse tipo de iterador. Pode ser pressuposto que um iterador de entrada possa ser desreferenciado para fazer referência a algum objeto e que possa ser incrementado para o próximo iterador na sequência. Esse é um conjunto mínimo de funcionalidade, mas é suficiente para poder expressar de modo significativo um intervalo de iteradores [First, Last) no contexto de funções de membro da classe.

Construtores

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

Typedefs

Nome	Descrição
`allocator_type`	Um tipo que representa a classe `allocator` para o objeto de conjunto.
`const_iterator`	Um tipo que fornece um iterador bidirecional que pode ler um elemento `const` no conjunto.
`const_pointer`	Um tipo que fornece um ponteiro para um elemento `const` em um conjunto.
`const_reference`	Um tipo que fornece uma referência para um elemento `const` armazenado em um conjunto para leitura e execução de operações `const`.
`const_reverse_iterator`	Um tipo que fornece um iterador bidirecional que pode ler qualquer elemento `const` no conjunto.
`difference_type`	Um tipo de inteiro com sinal que pode ser usado para representar o número de elementos de um conjunto em um intervalo entre os elementos apontado pelos iteradores.
`iterator`	Um tipo que fornece um iterador bidirecional que pode ler ou modificar qualquer elemento em um conjunto.
`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 conjunto.
`key_type`	O tipo descreve um objeto armazenado como um elemento de um conjunto em sua capacidade como chave de classificação.
`pointer`	Um tipo que fornece um ponteiro para um elemento em um conjunto.
`reference`	Um tipo que fornece uma referência a um elemento armazenado em um conjunto.
`reverse_iterator`	Um tipo que fornece um iterador bidirecional que pode ler ou modificar um elemento em um conjunto invertido.
`size_type`	Um tipo de inteiro sem sinal que pode representar o número de elementos em um conjunto.
`value_compare`	O tipo que fornece um objeto de função que pode comparar dois elementos para determinar sua ordem relativa no conjunto.
`value_type`	O tipo descreve um objeto armazenado como um elemento de um conjunto em sua capacidade como um valor.

Funções

Nome	Descrição
`begin`	Retorna um iterador que trata do primeiro elemento no `set`.
`cbegin`	Retorna um iterador const que trata o primeiro elemento no `set`.
`cend`	Retorna um iterador const que trata o local após o último elemento em um `set`.
`clear`	Apaga todos os elementos de um `set`.
`contains`^C++20	Verifique se há um elemento com a chave especificada no `set`.
`count`	Retorna o número de elementos em um `set` cuja chave corresponde a uma chave especificada pelo parâmetro.
`crbegin`	Retorna um iterador const que trata o primeiro elemento em um `set` invertido.
`crend`	Retorna um iterador const que trata o local após o último elemento em um `set` invertido.
`emplace`	Insere um elemento construído adequadamente em um `set`.
`emplace_hint`	Insere um elemento construído adequadamente em um `set`, com uma dica de posicionamento.
`empty`	Testa se `set` está vazio.
`end`	Retorna um iterador que trata o local após o último elemento em um `set`.
`equal_range`	Retorna um par de iteradores, respectivamente, para o primeiro elemento em um `set` com uma chave que é maior do que uma chave especificada e para o primeiro elemento no `set` com uma chave igual ou maior que a chave.
`erase`	Remove um elemento ou um intervalo de elementos em um conjunto das posições especificadas ou remove elementos que correspondem a uma chave especificada.
`find`	Retorna um iterador que trata do local de um elemento em um `set` que tem uma chave equivalente a uma chave especificada.
`get_allocator`	Retorna uma cópia do objeto `allocator` usada para construir o `set`.
`insert`	Insere um elemento ou um intervalo de elementos em um `set`.
`key_comp`	Recupera uma cópia do objeto de comparação usada para ordenar chaves em um `set`.
`lower_bound`	Retorna um iterador para o primeiro elemento em um conjunto com uma chave que é igual ou maior que uma chave especificada.
`max_size`	Retorna o comprimento máximo do `set`.
`rbegin`	Retorna um iterador que trata o primeiro elemento em um `set` invertido.
`rend`	Retorna um iterador que trata o local após o último elemento em um `set` invertido.
`size`	Retorna o número de elementos no `set`.
`swap`	Troca os elementos de dois `set`s.
`upper_bound`	Retorna um iterador para o primeiro elemento em um `set` com uma chave que é maior que uma chave especificada.
`value_comp`	Recupera uma cópia do objeto de comparação usado para ordenar valores de elemento em um `set`.

Operadores

Nome	Descrição
`operator=`	Substitui os elementos de um conjunto por uma cópia de outro conjunto.

`allocator_type`

Um tipo que representa a classe allocator do objeto set.

typedef Allocator allocator_type;

Comentários

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

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

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

Exemplo

Confira get_allocator, para ver um exemplo de uso de allocator_type.

`begin`

Retorna um iterador que trata o primeiro elemento no conjunto.

const_iterator begin() const;

iterator begin();

Valor de retorno

Um iterador bidirecional que trata o primeiro elemento no set ou o local após um set vazio.

Comentários

Se o valor retornado de begin foi atribuído a um const_iterator, os elementos no objeto set não poderão ser modificados. Se o valor retornado de begin foi atribuído a um iterator, os elementos no objeto set poderão ser modificados.

Exemplo

// set_begin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::iterator s1_Iter;
   set <int>::const_iterator s1_cIter;

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

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

   s1_Iter = s1.begin( );
   s1.erase( s1_Iter );

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

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

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

`cbegin`

Retorna um iterador const que trata o primeiro elemento no intervalo.

const_iterator cbegin() const;

Valor de retorno

Um iterador de acesso bidirecional const que aponta o primeiro elemento do intervalo ou o local logo após o fim de um intervalo vazio (para um intervalo vazio, cbegin() == cend()).

Comentários

Com o valor retornado de cbegin, os elementos no intervalo não podem ser modificados.

Você pode usar essa função membro no lugar da função membro begin(), de modo a garantir que o valor de retorno seja const_iterator. Normalmente, é usada em conjunto com a palavra-chave de dedução de tipo auto, conforme mostrado no exemplo a seguir. No exemplo, considere Container como um contêiner modificável (não const) de qualquer tipo, que dá suporte para begin() e cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`cend`

Retorna um iterador const que trata o local logo após o último elemento em um intervalo.

const_iterator cend() const;

Valor de retorno

Um iterador de acesso bidirecional const que aponta para além do fim do intervalo.

Comentários

cend é usado para testar se um iterador passou do fim de seu intervalo.

Você pode usar essa função membro no lugar da função membro end(), de modo a garantir que o valor de retorno seja const_iterator. Normalmente, é usada em conjunto com a palavra-chave de dedução de tipo auto, conforme mostrado no exemplo a seguir. No exemplo, considere Container como um contêiner modificável (não const) de qualquer tipo, que dá suporte para end() e cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

O valor retornado por cend não deve ser desreferenciado.

`clear`

Apaga todos os elementos de um conjunto.

void clear();

Exemplo

// set_clear.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;

   s1.insert( 1 );
   s1.insert( 2 );

   cout << "The size of the set is initially " << s1.size( )
        << "." << endl;

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

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

`const_iterator`

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

typedef implementation-defined const_iterator;

Comentários

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

Exemplo

Confira begin, para ver um exemplo de uso de const_iterator.

`const_pointer`

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

typedef typename allocator_type::const_pointer const_pointer;

Comentários

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 objeto const set.

`const_reference`

Um tipo que fornece uma referência para um elemento const armazenado em um conjunto para leitura e execução de operações const.

typedef typename allocator_type::const_reference const_reference;

Exemplo

// set_const_ref.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;

   s1.insert( 10 );
   s1.insert( 20 );

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

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

   // The following line would cause an error because the
   // const_reference can't be used to modify the set
   // Ref1 = Ref1 + 5;
}

The first element in the set is 10.

`const_reverse_iterator`

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

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Comentários

Um tipo const_reverse_iterator não pode modificar o valor de um elemento e é usado para iterar o set invertido.

Exemplo

Veja o exemplo de rend que demonstra como declarar e usar o const_reverse_iterator.

`contains`

Verifique se há um elemento com a chave especificada no set.

bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;

Parâmetros

K
Tipo da chave.

key
O valor-chave do elemento a ser procurado.

Valor de retorno

true se o elemento for localizado em set; caso contrário, false.

Comentários

contains() é novo em C++20. Para usá-lo, especifique a opção do compilador /std:c++20 ou posterior.

template<class K> bool contains(const K& key) const só participará da resolução de sobrecarga se key_compare for transparente. Confira Pesquisa heterogênea em contêineres associativos para obter mais informações.

Exemplo

// Requires /std:c++20 or /std:c++latest
#include <set>
#include <iostream>

int main()
{
    std::set<int> theSet = {1, 2};

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << theSet.contains(2) << '\n';
    std::cout << theSet.contains(3) << '\n';

    return 0;
}

true
false

`count`

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

size_type count(const Key& key) const;

Parâmetros

key
A chave dos elementos do set a serem correspondidos.

Valor de retorno

1 se o set contém um elemento cuja chave de classificação corresponde à chave de parâmetro. 0 se o set não contiver um elemento com uma chave correspondente.

Comentários

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

[ lower_bound(key), upper_bound(key) ).

Exemplo

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

// set_count.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
    using namespace std;
    set<int> s1;
    set<int>::size_type i;

    s1.insert(1);
    s1.insert(1);

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

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

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

`crbegin`

Retorna um iterador const que trata o primeiro elemento em um conjunto invertido.

const_reverse_iterator crbegin() const;

Valor de retorno

Um iterador bidirecional invertido const que trata do primeiro elemento em um set invertido ou que trata do que foi o último elemento do set não invertido.

Comentários

crbegin é usado com um set invertido, assim como begin é usado com um set.

Com o valor retornado de crbegin, o objeto set não pode ser modificado.

Exemplo

// set_crbegin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::const_reverse_iterator s1_crIter;

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

   s1_crIter = s1.crbegin( );
   cout << "The first element in the reversed set is "
        << *s1_crIter << "." << endl;
}

The first element in the reversed set is 30.

`crend`

Retorna um iterador const que trata o local após o último elemento em um conjunto invertido.

const_reverse_iterator crend() const;

Valor de retorno

Um iterador const bidirecional inverso que aborda a localização que vem após o último elemento em um set invertido (o local que precedeu o primeiro elemento no set não invertido).

Comentários

crend é usado com um set invertido, assim como end é usado com um set.

Com o valor retornado de crend, o objeto set não pode ser modificado. O valor retornado por crend não deve ser desreferenciado.

crend pode ser usado para testar se um iterador inverso alcançou o final de seu set.

Exemplo

// set_crend.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main() {
   using namespace std;
   set <int> s1;
   set <int>::const_reverse_iterator s1_crIter;

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

   s1_crIter = s1.crend( );
   s1_crIter--;
   cout << "The last element in the reversed set is "
        << *s1_crIter << "." << endl;
}

`difference_type`

Um tipo de inteiro com sinal que pode ser usado para representar o número de elementos de um conjunto em um intervalo entre os elementos apontado pelos iteradores.

typedef typename allocator_type::difference_type difference_type;

Comentários

difference_type é o tipo retornado ao subtrair ou incrementar por meio de iteradores do contêiner. O difference_type é geralmente 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 sem incluir, o elemento apontado por last.

Embora difference_type esteja disponível para todos os iteradores que atendem aos requisitos de um iterador de entrada, que inclui a classe de iteradores bidirecionais com suporte pelos contêineres reversíveis, como conjunto, a subtração entre iteradores só tem suporte pelos iteradores de acesso aleatório fornecidos por um contêiner de acesso aleatório, como vetor.

Exemplo

// set_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <set>
#include <algorithm>

int main( )
{
   using namespace std;

   set <int> s1;
   set <int>::iterator s1_Iter, s1_bIter, s1_eIter;

   s1.insert( 20 );
   s1.insert( 10 );
   s1.insert( 20 );   // won't insert as set elements are unique

   s1_bIter = s1.begin( );
   s1_eIter = s1.end( );

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

   df_typ5 = count( s1_bIter, s1_eIter, 5 );
   df_typ10 = count( s1_bIter, s1_eIter, 10 );
   df_typ20 = count( s1_bIter, s1_eIter, 20 );

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

   // count the number of elements in a set
   set <int>::difference_type  df_count = 0;
   s1_Iter = s1.begin( );
   while ( s1_Iter != s1_eIter)
   {
      df_count++;
      s1_Iter++;
   }

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

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

`emplace`

Insere um elemento criado no local (nenhuma operação de cópia ou movimentação é realizada).

template <class... Args>
pair<iterator, bool>
emplace(
    Args&&... args);

Parâmetros

args
Os argumentos encaminhados para construir um elemento a ser inserido no set, a menos que ele já contenha um elemento cujo valor seja ordenado de maneira equivalente.

Valor de retorno

Um pair cujo componente bool retornará true se uma inserção tiver sido feita, e false se o map já contiver um elemento cujo valor tinha um valor equivalente na ordenação. O componente de iterador do par de valores retornado retorna o endereço em que um novo elemento foi inserido (se o componente bool é true) ou em que o elemento já estava localizado (se o componente bool é false).

Comentários

Nenhum iterador ou referência será invalidada por essa função.

Durante o posicionamento, se uma exceção for lançada, o estado do contêiner não será modificado.

Exemplo

// set_emplace.cpp
// compile with: /EHsc
#include <set>
#include <string>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: ";

    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    set<string> s1;

    auto ret = s1.emplace("ten");

    if (!ret.second){
        cout << "Emplace failed, element with value \"ten\" already exists."
            << endl << "  The existing element is (" << *ret.first << ")"
            << endl;
        cout << "set not modified" << endl;
    }
    else{
        cout << "set modified, now contains ";
        print(s1);
    }
    cout << endl;

    ret = s1.emplace("ten");

    if (!ret.second){
        cout << "Emplace failed, element with value \"ten\" already exists."
            << endl << "  The existing element is (" << *ret.first << ")"
            << endl;
    }
    else{
        cout << "set modified, now contains ";
        print(s1);
    }
    cout << endl;
}

`emplace_hint`

Insere um elemento criado no local (nenhuma operação de cópia ou movimentação é realizada), com uma dica de posicionamento.

template <class... Args>
iterator emplace_hint(
    const_iterator where,
    Args&&... args);

Parâmetros

args
Os argumentos encaminhados para construir um elemento a ser inserido no set, a menos que o set já contenha esse elemento ou, de modo geral, que ele já contenha um elemento cujo valor seja ordenada de maneira equivalente.

where
O local a partir do qual se começa a procurar pelo ponto de inserção correto. (Se esse ponto preceder imediatamente where, a inserção poderá ocorrer em um tempo constante amortizado, em vez de no tempo logarítmico.)

Valor de retorno

Um iterador para o elemento recém-inserido.

Se a inserção tiver falhado porque o elemento já existe, ele retornará um iterador para o elemento existente.

Comentários

Nenhum iterador ou referência será invalidada por essa função.

Durante o posicionamento, se uma exceção for lançada, o estado do contêiner não será modificado.

Exemplo

// set_emplace.cpp
// compile with: /EHsc
#include <set>
#include <string>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: " << endl;

    for (const auto& p : s) {
        cout << "(" << p <<  ") ";
    }

    cout << endl;
}

int main()
{
    set<string> s1;

    // Emplace some test data
    s1.emplace("Anna");
    s1.emplace("Bob");
    s1.emplace("Carmine");

    cout << "set starting data: ";
    print(s1);
    cout << endl;

    // Emplace with hint
    // s1.end() should be the "next" element after this emplacement
    s1.emplace_hint(s1.end(), "Doug");

    cout << "set modified, now contains ";
    print(s1);
    cout << endl;
}

`empty`

Testa se um conjunto está vazio.

bool empty() const;

Valor de retorno

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

Exemplo

// set_empty.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1, s2;
   s1.insert ( 1 );

   if ( s1.empty( ) )
      cout << "The set s1 is empty." << endl;
   else
      cout << "The set s1 is not empty." << endl;

   if ( s2.empty( ) )
      cout << "The set s2 is empty." << endl;
   else
      cout << "The set s2 is not empty." << endl;
}

The set s1 is not empty.
The set s2 is empty.

`end`

Retorna o iterador que ultrapassa o fim.

const_iterator end() const;

iterator end();

Valor de retorno

O iterador que ultrapassa o fim. Se o conjunto estiver vazio, então, set::end() == set::begin().

Comentários

end é usado para testar se um iterador ultrapassou o fim do seu set.

O valor retornado por end não deve ser desreferenciado.

Para obter um exemplo de código, consulte set::find.

`equal_range`

Retorna um par de iteradores respectivamente para o primeiro elemento em um set com uma chave que é maior ou igual a uma chave especificada e para o primeiro elemento no set com uma chave maior que essa mesma chave especificada.

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

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

Parâmetros

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

Valor de retorno

Um par de iteradores em que 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. first e para desreferenciar o iterador de limite inferior, use *( pr. first). Para acessar o segundo iterador de um par pr retornado pela função membro, use pr. second e para desreferenciar o iterador de limite superior, use *( pr. second).

Exemplo

// set_equal_range.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   typedef set<int, less< int > > IntSet;
   IntSet s1;
   set <int, less< int > > :: const_iterator s1_RcIter;

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

   pair <IntSet::const_iterator, IntSet::const_iterator> p1, p2;
   p1 = s1.equal_range( 20 );

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

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

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

   p2 = s1.equal_range( 40 );

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

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

`erase`

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

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parâmetros

Where
A posição do elemento a ser removido.

First
A posição do primeiro elemento a ser removido.

Last
A posição logo após o último elemento a ser removido.

Key
O valor de chave dos elementos a serem removidos.

Valor de retorno

Para as duas primeiras funções membro, é um iterador bidirecional que designa o primeiro elemento restante além de quaisquer elementos removidos ou, se esse elemento não existe, é um elemento que é o final do set.

Para a terceira função membro, ele retorna o número de elementos que foram removidos do set.

Exemplo

// set_erase.cpp
// compile with: /EHsc
#include <set>
#include <string>
#include <iostream>
#include <iterator> // next() and prev() helper functions

using namespace std;

using myset = set<string>;

void printset(const myset& s) {
    for (const auto& iter : s) {
        cout << " [" << iter << "]";
    }
    cout << endl << "size() == " << s.size() << endl << endl;
}

int main()
{
    myset s1;

    // Fill in some data to test with, one at a time
    s1.insert("Bob");
    s1.insert("Robert");
    s1.insert("Bert");
    s1.insert("Rob");
    s1.insert("Bobby");

    cout << "Starting data of set s1 is:" << endl;
    printset(s1);
    // The 1st member function removes an element at a given position
    s1.erase(next(s1.begin()));
    cout << "After the 2nd element is deleted, the set s1 is:" << endl;
    printset(s1);

    // Fill in some data to test with, one at a time, using an initializer list
    myset s2{ "meow", "hiss", "purr", "growl", "yowl" };

    cout << "Starting data of set s2 is:" << endl;
    printset(s2);
    // The 2nd member function removes elements
    // in the range [First, Last)
    s2.erase(next(s2.begin()), prev(s2.end()));
    cout << "After the middle elements are deleted, the set s2 is:" << endl;
    printset(s2);

    myset s3;

    // Fill in some data to test with, one at a time, using emplace
    s3.emplace("C");
    s3.emplace("C#");
    s3.emplace("D");
    s3.emplace("D#");
    s3.emplace("E");
    s3.emplace("E#");
    s3.emplace("F");
    s3.emplace("F#");
    s3.emplace("G");
    s3.emplace("G#");
    s3.emplace("A");
    s3.emplace("A#");
    s3.emplace("B");

    cout << "Starting data of set s3 is:" << endl;
    printset(s3);
    // The 3rd member function removes elements with a given Key
    myset::size_type count = s3.erase("E#");
    // The 3rd member function also returns the number of elements removed
    cout << "The number of elements removed from s3 is: " << count << "." << endl;
    cout << "After the element with a key of \"E#\" is deleted, the set s3 is:" << endl;
    printset(s3);
}

`find`

Retorna um iterador que aponta para o local de um elemento em um conjunto que tem uma chave igual a uma chave especificada.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parâmetros

key
O valor da chave a ser comparado pela chave de classificação de um elemento do conjunto que está sendo pesquisado.

Valor de retorno

Um iterador que se refere ao local de um elemento com uma chave especificada ou o local que substitui o último elemento no conjunto (set::end()) se nenhuma correspondência for encontrada para a chave.

Comentários

A função de membro retorna um iterador que se refere a um elemento do set cuja chave é equivalente ao argumento key em um predicado binário que induz uma ordenação com base em uma relação de comparação menor.

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

Exemplo

// compile with: /EHsc /W4 /MTd
#include <set>
#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename T> void print_elem(const T& t) {
    cout << "(" << t << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

template <typename C, class T> void findit(const C& c, T val) {
    cout << "Trying find() on value " << val << endl;
    auto result = c.find(val);
    if (result != c.end()) {
        cout << "Element found: "; print_elem(*result); cout << endl;
    } else {
        cout << "Element not found." << endl;
    }
}

int main()
{
    set<int> s1({ 40, 45 });
    cout << "The starting set s1 is: " << endl;
    print_collection(s1);

    vector<int> v;
    v.push_back(43);
    v.push_back(41);
    v.push_back(46);
    v.push_back(42);
    v.push_back(44);
    v.push_back(44); // attempt a duplicate

    cout << "Inserting the following vector data into s1: " << endl;
    print_collection(v);

    s1.insert(v.begin(), v.end());

    cout << "The modified set s1 is: " << endl;
    print_collection(s1);
    cout << endl;
    findit(s1, 45);
    findit(s1, 6);
}

`get_allocator`

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

allocator_type get_allocator() const;

Valor de retorno

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

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

Comentários

Alocadores para a classe set especificam como a classe gerencia o armazenamento. Os alocadores padrão fornecidos com as classes de contêiner da biblioteca padrão C++ são suficientes para a maioria das necessidades de programação. Gravando e usando sua própria classe de alocador é um tópico avançado do C++.

Exemplo

// set_get_allocator.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int>::allocator_type s1_Alloc;
   set <int>::allocator_type s2_Alloc;
   set <double>::allocator_type s3_Alloc;
   set <int>::allocator_type s4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   set <int> s1;
   set <int, allocator<int> > s2;
   set <double, allocator<double> > s3;

   s1_Alloc = s1.get_allocator( );
   s2_Alloc = s2.get_allocator( );
   s3_Alloc = s3.get_allocator( );

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

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

   // The following line creates a set s4
   // with the allocator of multiset s1.
   set <int> s4( less<int>( ), s1_Alloc );

   s4_Alloc = s4.get_allocator( );

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

insert

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

// (1) single element
pair<iterator, bool> insert(
    const value_type& Val);

// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
    ValTy&& Val);

// (3) single element with hint
iterator insert(
    const_iterator Where,
    const value_type& Val);

// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

// (5) range
template <class InputIterator>
void insert(
    InputIterator First,
    InputIterator Last);

// (6) initializer list
void insert(
    initializer_list<value_type>
IList);

Parâmetros

Val
O valor de um elemento a ser inserido no conjunto, a menos que ele já contenha um elemento cujo valor seja ordenado de modo equivalente.

Where
O local a partir do qual se começa a procurar pelo ponto de inserção correto. (Se esse ponto preceder imediatamente Where, a inserção poderá ocorrer em um tempo constante amortizado, em vez de no tempo logarítmico.)

ValTy
O parâmetro de modelo que especifica o tipo de argumento que o set pode usar para construir um elemento de value_type e encaminhar perfeitamente Val como um argumento.

First
A posição do primeiro elemento a ser copiado.

Last
A posição imediatamente após o último elemento a ser copiado.

InputIterator
Argumento da função de modelo que atende aos requisitos de um iterador de entrada que aponta para elementos de um tipo que pode ser usado para construir objetos value_type.

IList
O initializer_list para o qual copiar os elementos.

Valor de retorno

As funções de membro de elemento único, (1) e (2), retornam um pair cujo componente bool será true se uma inserção tiver sido feita, e false se o set já contiver um elemento de valor equivalente na ordenação. O componente do iterador do par de valores retornados apontará para o elemento recém-inserido, se o componente bool for verdadeiro, ou para o elemento existente, se o componente bool for falso.

As funções do membro de elemento único com dica, (3) e (4), retornam um iterador que aponta para a posição em que o novo elemento foi inserido no conjunto ou, se um elemento com chave equivalente já existir, para o elemento existente.

Comentários

Nenhum iterador, ponteiro ou referência é invalidado por essa função.

Durante a inserção de apenas um elemento, se uma exceção for lançada, o estado do contêiner não será modificado. Durante a inserção de vários elementos, se uma exceção for lançada, o contêiner será deixado em um estado não especificado, mas válido.

Para acessar o componente iterador de um pair pr que é retornado pelas funções de membro de elemento único, use pr.first; para desreferenciar o iterador dentro do par retornado, use *pr.first, fornecendo um elemento. Para acessar o componente bool, use pr.second. Para obter um exemplo, consulte o código de amostra mais adiante neste artigo.

O value_type de um contêiner é um typedef que pertence ao contêiner e, para o set set<V>::value_type, é tipo const V.

A função do membro do intervalo (5) insere a sequência de valores de elemento em um set que corresponde a cada elemento abordado por um iterador no intervalo [First, Last); portanto, Last não é inserido. A função de membro do contêiner end() faz referência à posição imediatamente após o último elemento no contêiner; por exemplo, a instrução s.insert(v.begin(), v.end()); tenta inserir todos os elementos de v em s. Apenas elementos com valores únicos no intervalo são inseridos; as duplicatas são ignoradas. Para observar quais elementos são rejeitados, use as versões de elemento único de insert.

A função de membro da lista do inicializador (6) usa um initializer_list para copiar elementos no set.

Para inserir um elemento construído no lugar (ou seja, sem a realização de operação de cópia ou movimentação), confira set::emplace e set::emplace_hint.

Exemplo

// set_insert.cpp
// compile with: /EHsc
#include <set>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: ";

    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    // insert single values
    set<int> s1;
    // call insert(const value_type&) version
    s1.insert({ 1, 10 });
    // call insert(ValTy&&) version
    s1.insert(20);

    cout << "The original set values of s1 are:" << endl;
    print(s1);

    // intentionally attempt a duplicate, single element
    auto ret = s1.insert(1);
    if (!ret.second){
        auto elem = *ret.first;
        cout << "Insert failed, element with value 1 already exists."
            << endl << "  The existing element is (" << elem << ")"
            << endl;
    }
    else{
        cout << "The modified set values of s1 are:" << endl;
        print(s1);
    }
    cout << endl;

    // single element, with hint
    s1.insert(s1.end(), 30);
    cout << "The modified set values of s1 are:" << endl;
    print(s1);
    cout << endl;

    // The templatized version inserting a jumbled range
    set<int> s2;
    vector<int> v;
    v.push_back(43);
    v.push_back(294);
    v.push_back(41);
    v.push_back(330);
    v.push_back(42);
    v.push_back(45);

    cout << "Inserting the following vector data into s2:" << endl;
    print(v);

    s2.insert(v.begin(), v.end());

    cout << "The modified set values of s2 are:" << endl;
    print(s2);
    cout << endl;

    // The templatized versions move-constructing elements
    set<string>  s3;
    string str1("blue"), str2("green");

    // single element
    s3.insert(move(str1));
    cout << "After the first move insertion, s3 contains:" << endl;
    print(s3);

    // single element with hint
    s3.insert(s3.end(), move(str2));
    cout << "After the second move insertion, s3 contains:" << endl;
    print(s3);
    cout << endl;

    set<int> s4;
    // Insert the elements from an initializer_list
    s4.insert({ 4, 44, 2, 22, 3, 33, 1, 11, 5, 55 });
    cout << "After initializer_list insertion, s4 contains:" << endl;
    print(s4);
    cout << endl;
}

`iterator`

Um tipo que fornece um iterador bidirecional constante que pode ler qualquer elemento em um set.

typedef implementation-defined iterator;

Exemplo

Veja o exemplo de begin que demonstra como declarar e usar um iterator.

`key_comp`

Recupera uma cópia do objeto de comparação usada para ordenar chaves em um conjunto.

key_compare key_comp() const;

Valor de retorno

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

Para obter mais informações sobre Traits, confira o tópico set Classe.

Comentários

O objeto armazenado define a função membro:

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

que retornará true se _xVal for precedente e não igual a _yVal na ordem de classificação.

Ambos key_compare e value_compare são sinônimos do parâmetro de modelo Traits. Os dois tipos são fornecidos para as classes set e multiset, em que são idênticos, para compatibilidade com as classes map e multimap, em que são diferentes.

Exemplo

// set_key_comp.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;

   set <int, less<int> > s1;
   set<int, less<int> >::key_compare kc1 = s1.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 s1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of s1."
           << endl;
   }

   set <int, greater<int> > s2;
   set<int, greater<int> >::key_compare kc2 = s2.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 s2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of s2."
           << endl;
   }
}

kc1( 2,3 ) returns value of true, where kc1 is the function object of s1.
kc2( 2,3 ) returns value of false, where kc2 is the function object of s2.

`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 conjunto.

typedef Traits key_compare;

Comentários

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

Para obter mais informações sobre Traits, confira o tópico set Classe.

Exemplo

Veja o exemplo de key_comp que demonstra como declarar e usar key_compare.

`key_type`

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

typedef Key key_type;

Comentários

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

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

Ambos key_type e value_type são sinônimos do parâmetro de modelo Key. Os dois tipos são fornecidos para as classes set e multiset, em que são idênticos, para compatibilidade com as classes map e multimap, em que são diferentes.

Exemplo

Veja o exemplo de value_type que demonstra como declarar e usar key_type.

`lower_bound`

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

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parâmetros

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

Valor de retorno

Um iterador ou const_iterator que tratará a localização de um elemento em um set com uma chave, que é igual ou maior que a chave de argumento ou que tratará o local após o último elemento no set se nenhuma correspondência for encontrada para a chave.

Exemplo

// set_lower_bound.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int> :: const_iterator s1_AcIter, s1_RcIter;

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

   s1_RcIter = s1.lower_bound( 20 );
   cout << "The element of set s1 with a key of 20 is: "
        << *s1_RcIter << "." << endl;

   s1_RcIter = s1.lower_bound( 40 );

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

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

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

`max_size`

Retorna o comprimento máximo do conjunto.

size_type max_size() const;

Valor de retorno

O comprimento máximo possível do set.

Exemplo

// set_max_size.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::size_type i;

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

`operator=`

Substitui os elementos desse set usando os elementos de outro set.

set& operator=(const set& right);

set& operator=(set&& right);

Parâmetros

right
O set fornecendo novos elementos para serem atribuídos a este set.

Comentários

A primeira versão do operator= usa uma referência lvalue a right para copiar elementos de right a este set.

A segunda versão usa uma referência rvalue para right. Ela move elementos de right para este set.

Quaisquer elementos neste set antes de a função de operador ser executada serão descartados.

Exemplo

// set_operator_as.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
   {
   using namespace std;
   set<int> v1, v2, v3;
   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;
   }

`pointer`

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

typedef typename allocator_type::pointer pointer;

Comentários

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

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

`rbegin`

Retorna um iterador que trata o primeiro elemento em um conjunto invertido.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor de retorno

Um iterador bidirecional invertido que trata do primeiro elemento em um set invertido ou que trata do que foi o último elemento do set não invertido.

Comentários

rbegin é usado com um set invertido, assim como begin é usado com um set.

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

rbegin pode ser usado para iterar por de uma lista para trás.

Exemplo

// set_rbegin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::iterator s1_Iter;
   set <int>::reverse_iterator s1_rIter;

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

   s1_rIter = s1.rbegin( );
   cout << "The first element in the reversed set is "
        << *s1_rIter << "." << endl;

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

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

   // A set element can be erased by dereferencing to its key
   s1_rIter = s1.rbegin( );
   s1.erase ( *s1_rIter );

   s1_rIter = s1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed set is "<< *s1_rIter << "." << endl;
}

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

`reference`

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

typedef typename allocator_type::reference reference;

Exemplo

// set_reference.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;

   s1.insert( 10 );
   s1.insert( 20 );

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

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

The first element in the set is 10.

`rend`

Retorna um iterador que trata o local após o último elemento em um conjunto invertido.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valor de retorno

Um iterador bidirecional inverso que aborda a localização que vem após o último elemento em um set invertido (o local que precedeu o primeiro elemento no set não invertido).

Comentários

rend é usado com um set invertido, assim como end é usado com um set.

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

rend pode ser usado para testar se um iterador inverso alcançou o final de seu set.

Exemplo

// set_rend.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main() {
   using namespace std;
   set <int> s1;
   set <int>::iterator s1_Iter;
   set <int>::reverse_iterator s1_rIter;
   set <int>::const_reverse_iterator s1_crIter;

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

   s1_rIter = s1.rend( );
   s1_rIter--;
   cout << "The last element in the reversed set is "
        << *s1_rIter << "." << endl;

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

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

   s1_rIter = s1.rend( );
   s1_rIter--;
   s1.erase ( *s1_rIter );

   s1_rIter = s1.rend( );
   --s1_rIter;
   cout << "After the erasure, the last element in the "
        << "reversed set is " << *s1_rIter << "." << endl;
}

`reverse_iterator`

Um tipo que fornece um iterador bidirecional que pode ler ou modificar um elemento em um conjunto invertido.

typedef std::reverse_iterator<iterator> reverse_iterator;

Comentários

Um tipo reverse_iterator é usado para iterar pelo set em ordem inversa.

Exemplo

Veja o exemplo de rbegin que demonstra como declarar e usar reverse_iterator.

`set`

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

set();

explicit set(
    const Traits& Comp);

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

set(
    const set& Right);

set(
    set&& Right);

set(
    initializer_list<Type> IList);

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

set(
    initializer_list<Type> IList,
    const Compare& Comp,
    const Allocator& Al);

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

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

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

Parâmetros

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

Comp
A função de comparação do tipo const Traits usada para ordenar os elementos no set, cujo padrão é Compare.

Rght
O set do qual o conjunto criado é uma cópia.

First
A posição do primeiro elemento no intervalo de elementos a serem copiados.

Last
A posição do primeiro elemento além do intervalo de elementos a serem copiados.

IList
O initializer_list do qual copiar os elementos.

Comentários

Todos os construtores armazenam um tipo de objeto de alocador que gerencia o armazenamento de memória para o set e que, posteriormente, pode ser retornado ao chamar get_allocator. O parâmetro do alocador muitas vezes é omitido nas declarações de classe e nas macros de pré-processamento usadas para substituir os alocadores alternativos.

Todos os construtores inicializam seu set.

Todos os construtores armazenam um objeto de função do tipo Traits, que é usado para estabelecer uma ordem entre as chaves do set e que posteriormente pode ser retornado ao chamar key_comp.

O primeiro dos três construtores especifica um set inicial vazio, o segundo especifica o tipo de função de comparação (comp) a ser usada para estabelecer a ordem dos elementos e o terceiro especifica explicitamente o tipo de alocador (al) a ser usado. A palavra-chave explicit suprime determinados tipos de conversão de tipo automática.

O quarto construtor especifica uma cópia do set right.

Os próximos três construtores usam initializer_list para especificar os elementos.

Os próximos três construtores copiam o intervalo [ first, last) de um set com clareza crescente para especificar o tipo de função de comparação da classe Traits e de Allocator.

O oitavo construtor especifica uma cópia do set ao mover o right.

Exemplo

// set_set.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
    using namespace std;

    // Create an empty set s0 of key type integer
    set <int> s0;

    // Create an empty set s1 with the key comparison
    // function of less than, then insert 4 elements
    set <int, less<int> > s1;
    s1.insert(10);
    s1.insert(20);
    s1.insert(30);
    s1.insert(40);

    // Create an empty set s2 with the key comparison
    // function of less than, then insert 2 elements
    set <int, less<int> > s2;
    s2.insert(10);
    s2.insert(20);

    // Create a set s3 with the
    // allocator of set s1
    set <int>::allocator_type s1_Alloc;
    s1_Alloc = s1.get_allocator();
    set <int> s3(less<int>(), s1_Alloc);
    s3.insert(30);

    // Create a copy, set s4, of set s1
    set <int> s4(s1);

    // Create a set s5 by copying the range s1[ first,  last)
    set <int>::const_iterator s1_bcIter, s1_ecIter;
    s1_bcIter = s1.begin();
    s1_ecIter = s1.begin();
    s1_ecIter++;
    s1_ecIter++;
    set <int> s5(s1_bcIter, s1_ecIter);

    // Create a set s6 by copying the range s4[ first,  last)
    // and with the allocator of set s2
    set <int>::allocator_type s2_Alloc;
    s2_Alloc = s2.get_allocator();
    set <int> s6(s4.begin(), ++s4.begin(), less<int>(), s2_Alloc);

    cout << "s1 =";
    for (auto i : s1)
        cout << " " << i;
    cout << endl;

    cout << "s2 = " << *s2.begin() << " " << *++s2.begin() << endl;

    cout << "s3 =";
    for (auto i : s3)
        cout << " " << i;
    cout << endl;

    cout << "s4 =";
    for (auto i : s4)
        cout << " " << i;
    cout << endl;

    cout << "s5 =";
    for (auto i : s5)
        cout << " " << i;
    cout << endl;

    cout << "s6 =";
    for (auto i : s6)
        cout << " " << i;
    cout << endl;

    // Create a set by moving s5
    set<int> s7(move(s5));
    cout << "s7 =";
    for (auto i : s7)
        cout << " " << i;
    cout << endl;

    // Create a set with an initializer_list
    cout << "s8 =";
    set<int> s8{ { 1, 2, 3, 4 } };
    for (auto i : s8)
        cout << " " << i;
    cout << endl;

    cout << "s9 =";
    set<int> s9{ { 5, 6, 7, 8 }, less<int>() };
    for (auto i : s9)
        cout << " " << i;
    cout << endl;

    cout << "s10 =";
    set<int> s10{ { 10, 20, 30, 40 }, less<int>(), s9.get_allocator() };
    for (auto i : s10)
        cout << " " << i;
    cout << endl;
}

s1 = 10 20 30 40s2 = 10 20s3 = 30s4 = 10 20 30 40s5 = 10 20s6 = 10s7 = 10 20s8 = 1 2 3 4s9 = 5 6 7 8s10 = 10 20 30 40

`size`

Retorna o número de elementos no conjunto.

size_type size() const;

Valor de retorno

O comprimento atual do set.

Exemplo

// set_size.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int> :: size_type i;

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

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

The set length is 1.
The set length is now 2.

`size_type`

Um tipo de inteiro sem sinal que pode representar o número de elementos em um conjunto.

typedef typename allocator_type::size_type size_type;

Exemplo

Veja o exemplo de size que demonstra como declarar e usar size_type

`swap`

Troca os elementos de dois conjuntos.

void swap(
    set<Key, Traits, Allocator>& right);

Parâmetros

right
O set de argumentos que fornece os elementos a serem trocados com o set de destino.

Comentários

A função membro não invalida nenhuma referência, ponteiro ou iterador que designa elementos nos dois sets cujos elementos estão sendo trocados.

Exemplo

// set_swap.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1, s2, s3;
   set <int>::iterator s1_Iter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );
   s2.insert( 100 );
   s2.insert( 200 );
   s3.insert( 300 );

   cout << "The original set s1 is:";
   for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )
      cout << " " << *s1_Iter;
   cout   << "." << endl;

   // This is the member function version of swap
   s1.swap( s2 );

   cout << "After swapping with s2, list s1 is:";
   for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )
      cout << " " << *s1_Iter;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( s1, s3 );

   cout << "After swapping with s3, list s1 is:";
   for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )
      cout << " " << *s1_Iter;
   cout   << "." << endl;
}

The original set s1 is: 10 20 30.
After swapping with s2, list s1 is: 100 200.
After swapping with s3, list s1 is: 300.

`upper_bound`

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

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parâmetros

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

Valor de retorno

Um iterator ou const_iterator que tratará a localização de um elemento em um set com uma chave que é maior que a chave de argumento ou que tratará o local após o último elemento no set se nenhuma correspondência for encontrada para a chave.

Exemplo

// set_upper_bound.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int> :: const_iterator s1_AcIter, s1_RcIter;

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

   s1_RcIter = s1.upper_bound( 20 );
   cout << "The first element of set s1 with a key greater "
        << "than 20 is: " << *s1_RcIter << "." << endl;

   s1_RcIter = s1.upper_bound( 30 );

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

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

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

`value_comp`

Recupera uma cópia do objeto de comparação usada para ordenar valores de elemento em um conjunto.

value_compare value_comp() const;

Valor de retorno

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

Para obter mais informações sobre Traits, confira o tópico set Classe.

Comentários

O objeto armazenado define a função membro:

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

que retornará true se _xVal for precedente e não igual a _yVal na ordem de classificação.

Ambos value_compare e key_compare são sinônimos do parâmetro de modelo Traits. Os dois tipos são fornecidos para as classes set e multiset, em que são idênticos, para compatibilidade com as classes map e multimap, em que são diferentes.

Exemplo

// set_value_comp.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;

   set <int, less<int> > s1;
   set <int, less<int> >::value_compare vc1 = s1.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 s1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of s1."
           << endl;
   }

   set <int, greater<int> > s2;
   set<int, greater<int> >::value_compare vc2 = s2.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 s2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of s2."
           << endl;
   }
}

vc1( 2,3 ) returns value of true, where vc1 is the function object of s1.
vc2( 2,3 ) returns value of false, where vc2 is the function object of s2.

`value_compare`

Um tipo que fornece um objeto de função que pode comparar dois valores de elemento para determinar sua ordem relativa no conjunto.

typedef key_compare value_compare;

Comentários

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

Para obter mais informações sobre Traits, confira o tópico set Classe.

Exemplo

Veja o exemplo de value_comp que demonstra como declarar e usar value_compare.

`value_type`

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

typedef Key value_type;

Comentários

value_type é um sinônimo do parâmetro de modelo Key.

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

Exemplo

// set_value_type.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::iterator s1_Iter;

   set <int>::value_type svt_Int;   // Declare value_type
   svt_Int = 10;            // Initialize value_type

   set <int> :: key_type skt_Int;   // Declare key_type
   skt_Int = 20;             // Initialize key_type

   s1.insert( svt_Int );         // Insert value into s1
   s1.insert( skt_Int );         // Insert key into s1

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

The set has elements: 10 20.

Compartilhar via

Classe set

Sintaxe

Parâmetros

Comentários

Construtores

Typedefs

Funções

Operadores

allocator_type

Comentários

Exemplo

begin

Valor de retorno

Comentários

Exemplo

cbegin

Valor de retorno

Comentários

cend

Valor de retorno

Comentários

clear

Exemplo

const_iterator

Comentários

Exemplo

const_pointer

Comentários

const_reference

Exemplo

const_reverse_iterator

Comentários

Exemplo

contains

Parâmetros

Valor de retorno

Comentários

Exemplo

count

Parâmetros

Valor de retorno

Comentários

Exemplo

crbegin

Valor de retorno

Comentários

Exemplo

crend

Valor de retorno

Comentários

Exemplo

difference_type

Comentários

Exemplo

emplace

Parâmetros

Valor de retorno

Comentários

Exemplo

emplace_hint

Parâmetros

Valor de retorno

Comentários

Exemplo

empty

Valor de retorno

Exemplo

end

Valor de retorno

Comentários

equal_range

Parâmetros

Valor de retorno

Exemplo

erase

Parâmetros

Valor de retorno

Exemplo

find

Classe `set`

`allocator_type`

`begin`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`contains`

`count`

`crbegin`

`crend`

`difference_type`

`emplace`

`emplace_hint`

`empty`

`end`

`equal_range`

`erase`

`find`

`get_allocator`

`iterator`

`key_comp`

`key_compare`

`key_type`

`lower_bound`

`max_size`

`operator=`

`pointer`

`rbegin`

`reference`

`rend`

`reverse_iterator`

`set`

`size`

`size_type`

`swap`

`upper_bound`

`value_comp`