A função de membro da apagamento no conjunto de std c ++

Depois que os valores foram inseridos em um conjunto em C ++, os valores são classificados internamente em ordem crescente quando as configurações são padrão. A classe Set em C ++ tem a função de membro EASE (). Possui quatro variantes sobrecarregadas que são exploradas neste artigo. A função apaga um ou mais elementos do objeto Set.

Um exemplo de conjunto é:

"Plum", "BlackBerry", "Apricot", "Strawberry", "Peach", "Papaya", "Guava"

É um conjunto de nomes de frutas. Cada valor aqui é chamado de chave. Este também é o conjunto literal em c++. É a matriz literal também. E também é o Initializer_list.

Um programa C ++ que cria conjuntos e strings deve começar da seguinte forma:

#incluir
#incluir
#incluir
usando namespace std;

A inclusão da biblioteca iostream é para saída (e entrada) no terminal (console). A inclusão da biblioteca de conjuntos é para conjuntos. A inclusão da biblioteca de cordas é para strings. Se os ponteiros de char* são usados ​​em vez da classe de cordas, então são os ponteiros dos literais de char que serão classificados e não os próprios literais alfabéticos de cordas. Estes são todos sub-bibliotecas da biblioteca padrão principal em C++. DST no título deste artigo significa padrão. A quarta linha não é uma diretiva. É uma declaração que termina em um ponto de vírgula. Isso insiste que qualquer nome que não seja precedido pelo nome de namespace padrão é do espaço de nome padrão.

Nota: Quando os valores são inseridos no objeto Set, eles são classificados ascendentes, internamente, para as configurações padrão.

size_type apagar (const key_type & x)

Isso apaga a chave, cujo nome é o argumento da função do membro EASE (). O programador precisa saber com antecedência que essa chave existe no conjunto. A função retorna o número de elementos apagados do conjunto. O programa a seguir mostra como usar esta função de membro:

#incluir
#incluir
#incluir
usando namespace std;
int main ()

setst ("Plum", "BlackBerry", "Apricot", "Strawberry", "Peach", "Papaya", "GUAVA");
int sz = st.apagar ("mamão");
cout<para (set :: iterator iter = st.começar(); iter != st.fim(); iter ++)
cout<< *iter<< ", ";
cout<retornar 0;

A saída é:

1
Damasco, amora, goiaba, pêssego, ameixa, morango,

apagar iterador (posição do iterador)

Esta função de membro apaga a chave que o iterador está apontando para. O código a seguir ilustra o seguinte:

setst ("Plum", "BlackBerry", "Apricot", "Strawberry", "Peach", "Papaya", "GUAVA");
para (set :: iterator iter = st.começar(); iter != st.fim(); iter ++)
cout<< *iter<< ", ";
if ("mamão" == *iter)
st.apagar (iter);

cout<para (set :: iterator ite = st.começar(); eu te != st.fim(); Ite ++)
cout<< *ite<< ", ";

cout<A saída é:

Damasco, amora, goiaba, mamão, goiaba, pêssego, ameixa, morango,
Damasco, amora, goiaba, pêssego, ameixa, morango,

"Papaya" foi excluído. Como foi excluído, a goiaba tomou seu lugar pela classificação interna. É por isso que a goiaba apareceu duas vezes na primeira linha de saída.

Erase do iterador (posição const_iterator)

Esta função de membro sobrecarregada é a mesma que acima, exceto que o argumento é um iterador constante. Ainda retorna o iterador normal. O iterador devolvido aponta para o próximo elemento após o que foi apagado com base na classificação interna. O programa a seguir ilustra tudo isso:

setst ("Plum", "BlackBerry", "Apricot", "Strawberry", "Peach", "Papaya", "GUAVA");
set :: iterator ite;
para (set :: const_iteratoriter = st.começar(); iter != st.fim(); iter ++)
cout<< *iter<< ", ";
if ("mamão" == *iter)
ite = st.apagar (iter);

cout<para (set :: iterator it = st.começar(); isto != st.fim(); It ++)
cout<< *it << ", ";

cout<A saída é:

Damasco, amora, goiaba, mamão, goiaba, pêssego, ameixa, morango,
pêssego
Damasco, amora, goiaba, pêssego, ameixa, morango,

Erase do iterador (const_iterator primeiro, const_iterator Último)

"Primeiro" é um iterador apontando para um elemento no conjunto classificado. "Last" é um iterador apontando para um elemento no conjunto classificado após o primeiro. Os iteradores de argumento são iteradores constantes. Esta função de membro apaga um intervalo que inclui o elemento para "primeiro" e que exclui o elemento para o último. O código a seguir ilustra o seguinte:

setst ("Plum", "BlackBerry", "Apricot", "Strawberry", "Peach", "Papaya", "GUAVA");
para (set :: iterator it = st.começar(); isto != st.fim(); It ++)
cout<< *it << ", ";
cout<set :: const_iteratoritb = st.começar(); set :: const_iteratorite = st.fim();
itb ++; itb ++; eu te--; eu te--; eu te--;
set :: iterator ite = st.apagar (ITB, ITE);
para (set :: iterator it = st.começar(); isto != st.fim(); It ++)
cout<< *it << ", ";

cout<A saída é:

Damasco, amora, goiaba, mamão, pêssego, ameixa, morango,
Damasco, amora, pêssego, ameixa, morango,

A gama de "goiaba, mamão, pêssego", excluindo "pêssego", foi removida.

Substituindo um valor

O conjunto em C ++ não possui nenhuma função de membro para substituir um valor; E não deveria ter. Isso ocorre porque cada vez que um valor é inserido, há uma re-classificação completa do conjunto (lista). Portanto, não faz sentido substituir um valor cuja posição mudará após a renascimento. No entanto, se um valor for apagado, um novo valor poderá ser inserido que passará por ajuste de posição. No programa a seguir, "BlackBerry" é apagado e "melancia" é inserido. O tamanho total permanece o mesmo em 7.

#incluir
#incluir
#incluir
usando namespace std;
int main ()

setst ("Plum", "BlackBerry", "Apricot", "Strawberry", "Peach", "Papaya", "GUAVA");
st.apagar ("BlackBerry"); st.inserir ("melancia");
para (set :: iterator it = st.começar(); isto != st.fim(); It ++)
cout<< *it << ", ";
cout<int sz = st.tamanho();
cout<retornar 0;

A saída é:

Damasco, goiaba, mamão, pêssego, ameixa, morango, melancia,
7

Conclusão

Em C ++, a classe Set está na biblioteca definida da Biblioteca Padrão C ++ principal. A classe Set possui quatro funções de membro sobrecarregadas (). Um único elemento pode ser apagado. Uma variedade de elementos excluindo o último elemento também pode ser apagada. Após cada ação de apagar, o conjunto é reembolsado internamente.

O conjunto em C ++ não possui nenhuma função de membro para substituir um valor; E não deveria ter. Isso ocorre porque cada vez que um valor é inserido, há uma remoção completa do conjunto (lista). Portanto, não faz sentido substituir um valor cuja posição mudará após a renascimento.