set Classe

A classe set de contêiner C++ Standard Library é usada para armazenar e recuperar dados de uma coleção. Os valores dos elementos no set são únicos e servem como os valores-chave de acordo com os quais os dados são ordenados automaticamente. O valor de um elemento em a 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 less <Key> binário é o valor padrão.

Em C++14, você pode habilitar a pesquisa heterogênea especificando o predicado std::less<> ou std::greater<> que não tem parâmetros de tipo. Consulte Pesquisa heterogênea em contêineres associativos para obter mais informações.

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

Observações

Um conjunto de bibliotecas padrão C++ é:

• 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.

• Classificado, porque seus elementos são ordenados por valores-chave dentro do contêiner de acordo com uma função de comparação especificada.

• Único no sentido de que cada um dos seus elementos deve ter uma chave única. Como o conjunto também é um simples recipiente associativo, seus elementos também são únicos.

Um conjunto também é descrito como um modelo de classe porque a funcionalidade que ele fornece é genérica e independente do tipo específico de dados contidos como elementos. O tipo de dados a ser usado é, em vez disso, 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 contentor deve basear-se, em geral, no tipo de pesquisa e inserção exigido pela aplicação. Os contêineres associativos 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, fazendo-as em um tempo que é, em média, proporcional ao logaritmo do número de elementos no contêiner. A inserção de elementos não invalida nenhum iterador e a remoção de elementos invalida apenas os iteradores que apontaram para os elementos removidos.

O conjunto deve ser o recipiente associativo de escolha quando as condições que associam os valores às suas chaves são satisfeitas pelo aplicativo. Os elementos de um conjunto 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 multiconjunto seria a estrutura de contêiner apropriada. Se os valores precisarem ser anexados 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, então um multimapa seria o recipiente de escolha.

O conjunto ordena a sequência que controla chamando um objeto de função armazenado do tipo key_compare. Este objeto armazenado é uma função de comparação que pode ser acessada chamando a função key_compde membro. 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 conjunto é 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 fx,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.

Em C++14, você pode habilitar a pesquisa heterogênea especificando o predicado std::less<> ou std::greater<> que não tem parâmetros de tipo. Consulte Pesquisa heterogênea em contêineres associativos para obter mais informações.

O iterador fornecido pela classe set é um iterador bidirecional, mas o membro da classe funciona insert e set tem 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

Typedefs (definições de tipos)

Funções

Operadores

allocator_type

Um tipo que representa a classe alocator para o objeto set.

typedef Allocator allocator_type;

Observações

allocator_type é 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 Allocatortemplate .

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

Exemplo

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

begin

Retorna um iterador que aborda o primeiro elemento do conjunto.

const_iterator begin() const;

iterator begin();

Valor de retorno

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

Observações

Se o valor de retorno de begin for atribuído a um const_iterator, os elementos no objeto set não poderão ser modificados. Se o valor de retorno de begin for 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 aborda o primeiro elemento no intervalo.

const_iterator cbegin() const;

Valor de retorno

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

Observações

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

Você pode usar essa função de membro no lugar da função de membro begin() para garantir que o valor de retorno seja const_iterator. Normalmente, ele é usado em conjunto com a palavra-chave de dedução de tipo auto, conforme mostrado no exemplo a seguir. No exemplo, considere Container como um recipiente modificável (não const) de qualquer tipo que suporte 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 aborda o local logo após o último elemento de um intervalo.

const_iterator cend() const;

Valor de retorno

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

Observações

cend é usado para testar se um iterador passou no final de seu intervalo.

Você pode usar essa função de membro no lugar da função de membro end() para garantir que o valor de retorno seja const_iterator. Normalmente, ele é usado em conjunto com a palavra-chave de dedução de tipo auto, conforme mostrado no exemplo a seguir. No exemplo, considere Container como um recipiente modificável (não const) de qualquer tipo que suporte 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 const elemento no conjunto.

typedef implementation-defined const_iterator;

Observações

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

Exemplo

Veja o exemplo para begin para um exemplo que usa const_iterator.

const_pointer

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

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

const_reference

Um tipo que fornece uma referência a um const elemento armazenado em um conjunto para operações de leitura e execução 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 const elemento no conjunto.

typedef std::reverse_iterator<const_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 conjunto no sentido inverso.

Exemplo

Veja o exemplo para rend obter um exemplo de 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
O tipo da chave.

key
O valor-chave do elemento a procurar.

Valor de retorno

true se o elemento for encontrado no set; false caso contrário.

Observações

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

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

Exemplo

// Requires /std:c++20 or later
#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 por parâmetro.

size_type count(const Key& key) const;

Parâmetros

key
A chave dos elementos a serem combinados a partir do conjunto.

Valor de retorno

1 se o conjunto contiver um elemento cuja chave de classificação corresponda à chave de parâmetro. 0 se o conjunto 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(key), upper_bound(key) ).

Exemplo

O exemplo a seguir demonstra o uso da função member 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 endereçando o primeiro elemento em um conjunto invertido.

const_reverse_iterator crbegin() const;

Valor de retorno

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

Observações

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

Com o valor de retorno 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 aborda o local que sucede o último elemento em um conjunto invertido.

const_reverse_iterator crend() const;

Valor de retorno

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

Observações

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

Com o valor de retorno 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 reverso atingiu o final de seu conjunto.

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 assinado que pode ser usado para representar o número de elementos de um conjunto em um intervalo entre elementos apontados por iteradores.

typedef typename 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 [ primeiro, último) 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.

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.

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 construído no local (nenhuma operação de cópia ou movimentação é executada).

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

Parâmetros

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

Valor de retorno

A pair cujo componente bool retorna true se uma inserção foi feita, e false se o mapa já continha um elemento cujo valor tinha um valor equivalente na ordem. O componente iterador do par de valores de retorno retorna o endereço onde um novo elemento foi inserido (se o componente bool for true) ou onde o elemento já estava localizado (se o componente bool for false).

Observações

Nenhum iterador ou referência é invalidado por esta função.

Durante a colocação, 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 construído no local (nenhuma operação de cópia ou movimentação é executada), 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 conjunto, a menos que o conjunto já contenha esse elemento ou, mais geralmente, a menos que já contenha um elemento cujo valor seja ordenado equivalentemente.

where
O lugar para começar a procurar o ponto correto de inserção. (Se esse ponto preceder whereimediatamente, a inserção pode ocorrer em tempo constante amortizado em vez de tempo logarítmico.)

Valor de retorno

Um iterador para o elemento recém-inserido.

Se a inserção falhou porque o elemento já existe, retorna um iterador para o elemento existente.

Observações

Nenhum iterador ou referência é invalidado por esta função.

Durante a colocação, 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 conjunto estiver vazio; false se o conjunto 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 passado-a-fim.

const_iterator end() const;

iterator end();

Valor de retorno

O iterador passado-a-fim. Se o conjunto estiver vazio, então set::end() == set::begin().

Observações

end é usado para testar se um iterador passou no final de seu conjunto.

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 conjunto com uma chave que é maior ou igual a uma chave especificada e para o primeiro elemento no conjunto 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

key
A chave de argumento a ser comparada com a chave de classificação de um elemento do conjunto 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 de 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

// 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 de 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
Posição do elemento a remover.

First
Posição do primeiro elemento a ser removido.

Last
Posicione logo após o último elemento a ser removido.

Key
O valor-chave dos elementos a serem removidos.

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 elemento que é o final do conjunto se tal elemento não existir.

Para a função de terceiro membro, retorna o número de elementos que foram removidos do conjunto.

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 se refere ao local de um elemento em um conjunto que tem uma chave equivalente 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 correspondido 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 sucede o último elemento no conjunto (set::end()) se nenhuma correspondência for encontrada para a chave.

Observações

A função member retorna um iterador que se refere a um elemento no conjunto cuja chave é equivalente à chave de argumento sob um predicado binário que induz uma ordenação baseada em uma relação de menor comparabilidade.

Se o valor de retorno de find for atribuído a um const_iterator, o objeto set não poderá ser modificado. Se o valor de retorno 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 conjunto.

allocator_type get_allocator() const;

Valor de retorno

O alocador usado pelo conjunto para gerenciar a memória, que é o parâmetro Allocatordo modelo.

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

Observações

Os alocadores para a classe 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

// 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;
   }
}

inserir

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 esteja ordenado equivalentemente.

Where
O lugar para começar a procurar o ponto correto de inserção. (Se esse ponto precede imediatamente Where, a inserção pode ocorrer em tempo constante amortizado em vez de tempo logarítmico.)

ValTy
Parâmetro de modelo que especifica o tipo de argumento que o conjunto pode usar para construir um elemento de value_type, e perfect-forwards Val como um argumento.

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

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

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

IList
O initializer_list do qual copiar os elementos.

Valor de retorno

As funções de membro de elemento único, (1) e (2), retornam um pair cujo bool componente é true se uma inserção foi feita, e false se o conjunto já continha um elemento de valor equivalente na ordem. O componente iterador do par de valor de retorno aponta para o elemento recém-inserido, se o bool componente for true, ou para o elemento existente, se o bool componente for false.

As funções de membro single-element-with-hint, (3) e (4), retornam um iterador que aponta para a posição onde o novo elemento foi inserido no conjunto ou, se um elemento com uma chave equivalente já existir, para o elemento existente.

Observações

Nenhum iterador, ponteiro ou referência é invalidado por esta 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 pairpr retornado pelas funções de membro de elemento único, use pr.first; Para cancelar a referência do 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 exemplo mais adiante neste artigo.

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

A função de membro do intervalo (5) insere a sequência de valores de elementos em um conjunto que corresponde a cada elemento abordado por um iterador no intervalo [First, Last), portanto, Last não é inserida. A função de membro do contêiner end() refere-se à posição logo 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 os elementos que têm valores exclusivos no intervalo são inseridos; duplicados são ignorados. Para observar quais elementos são rejeitados, use as versões de elemento único do insert.

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

Para inserção de um elemento construído no local, ou seja, nenhuma operação de cópia ou movimentação é executada, consulte 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 conjunto.

typedef implementation-defined iterator;

Exemplo

Veja o exemplo para begin obter um exemplo de como declarar e usar um iteratorarquivo .

key_comp

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

key_compare key_comp() const;

Valor de retorno

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

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

Observações

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

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

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

Ambos key_compare e value_compare são sinônimos para o parâmetro Traitstemplate . 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

// 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;

Observações

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

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

Ambos key_compare e value_compare são sinônimos para o parâmetro Traitstemplate . 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 obter um exemplo de como declarar e usar key_compare.

key_type

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

typedef Key key_type;

Observações

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

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

Ambos key_type e value_type são sinônimos para o parâmetro Keytemplate . 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 value_type obter um exemplo de como declarar e usar key_type.

lower_bound

Retorna um iterador para o primeiro elemento de um conjunto com uma chave 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 de argumento a ser comparada com a chave de classificação de um elemento do conjunto que está sendo pesquisado.

Valor de retorno

Um iterador ou const_iterator que aborda o local de um elemento em um conjunto que com uma chave que é igual ou maior do que a chave de argumento ou que aborda o local que sucede o último elemento no conjunto 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

Devolve o comprimento máximo do conjunto.

size_type max_size() const;

Valor de retorno

O comprimento máximo possível do conjunto.

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 deste set usando elementos de outro set.

set& operator=(const set& right);

set& operator=(set&& right);

Parâmetros

right
O set fornecimento de novos elementos a serem atribuídos a este set.

Observações

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

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

Quaisquer elementos nisso set antes que a função do operador seja executada sã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;

Observações

Um tipo 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 definido.

rbegin

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

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor de retorno

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

Observações

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

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

rbegin pode ser usado para iterar através de um conjunto 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 aborda o local que sucede o último elemento em um conjunto 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 conjunto invertido (o local que precedeu o primeiro elemento no conjunto não invertido).

Observações

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

Se o valor de retorno de rend for atribuído a um const_reverse_iterator, o objeto set não poderá ser modificado. Se o valor de retorno de rend for atribuído a um 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 reverso atingiu o final de seu conjunto.

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;

Observações

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

Exemplo

Veja o exemplo para rbegin obter um exemplo de 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 usada 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 conjunto, cujo padrão é Compare.

Rght
O conjunto do qual o conjunto construído deve ser uma cópia.

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

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

IList
O initializer_list do qual copiar os elementos.

Observações

Todos os construtores armazenam um tipo de objeto alocador que gerencia o armazenamento de memória para o conjunto e que pode ser retornado posteriormente chamando 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 conjuntos.

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

Os três primeiros construtores especificam um conjunto inicial vazio, 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 construtor especifica uma cópia do conjunto right.

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

Os próximos três construtores copiam o intervalo [ first, last) de um conjunto com crescente explicitação na especificação do tipo de função de comparação de classe Traits e Allocator.

O oitavo construtor especifica uma cópia do conjunto movendo 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 conjunto.

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 não assinado que pode representar o número de elementos em um conjunto.

typedef typename allocator_type::size_type size_type;

Exemplo

Veja o exemplo para size obter um exemplo de como declarar e usar size_type

swap

Troca os elementos de dois conjuntos.

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

Parâmetros

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

Observações

A função de membro não invalida referências, ponteiros ou iteradores que designam elementos nos dois conjuntos 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 conjunto 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

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

Valor de retorno

Um iterator ou const_iterator que aborda o local de um elemento em um conjunto que com uma chave que é maior do que a chave de argumento, ou que aborda o local que sucede o último elemento no conjunto 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 usado para ordenar valores de elementos em um conjunto.

value_compare value_comp() const;

Valor de retorno

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

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

Observações

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

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

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

Ambos value_compare e key_compare são sinônimos para o parâmetro Traitstemplate . 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

// 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;

Observações

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

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

Ambos key_compare e value_compare são sinônimos para o parâmetro Traitstemplate . 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 value_comp obter um exemplo de como declarar e usar value_compare.

value_type

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

typedef Key value_type;

Observações

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

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

Ambos key_type e value_type são sinônimos para o parâmetro Keytemplate . 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

// 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.