C ++ vetor claro vs apagar

O vetor C ++ tem muitas funções de membro. Dois deles são claro () e EASE (). claro() "Remove" todos os elementos do vetor. EASE () “remove” um único elemento ou uma variedade de elementos. Existem duas variantes sobrecarregadas da função de membro EASE () para o vetor.

O título deste artigo é na verdade “Função do membro do Vector Clear () versus Vector EASE () Membro, em C ++”. Esta é uma comparação das funções de dois membros. Ele lida com quando usar qual, como usar qual e sob quais condições são usadas.

Para usar um vetor em um programa C ++, o programa deve começar com:

#incluir
#incluir
usando namespace std;

Conteúdo do artigo

• Vetor claro ()
• Apagação do vetor
• Pop_back
• Destruindo um vetor
• Conclusão

Vetor claro ()

A função Clear () do membro "remove" todos os elementos do vetor. Sua sintaxe é:

vazio claro ()

Ele retorna vazio. O programa a seguir ilustra seu uso, com a expressão: “VTR.claro();":

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

vetor vtr = 'p', 'q', 'r', 's', 't', 'u';
para (vetor:: iterator it = vtr.começar(); isto != vtr.fim(); IT ++)
cout << *it << ";
cout << endl;
vtr.claro();
para (vetor:: iterator it = vtr.começar(); isto != vtr.fim(); IT ++)
cout << *it << ";
cout << endl;
retornar 0;

A saída é a única linha:

P q r s t u

Se o vetor não tivesse sido limpo, a saída teria sido duas linhas da mesma sequência. Nenhuma segunda linha foi exibida porque todos os elementos foram limpos.

const vetor e claro ()

Quando uma declaração de vetor é precedida por const, significa que os elementos do vetor não podem ser excluídos ou alterados. Se uma expressão tentar mudar ou excluir qualquer um dos elementos, o programa não compilará. Teste o programa a seguir e observar que ele não compila:

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

const vetor vtr = 'p', 'q', 'r', 's', 't', 'u';
para (vetor:: const_iterator it = vtr.começar(); isto != vtr.fim(); IT ++)
cout << *it << ";
cout << endl;
vtr.claro();
para (vetor:: const_iterator it = vtr.começar(); isto != vtr.fim(); IT ++)
cout << *it << ";
cout << endl;
retornar 0;

Se o programa fosse testado, uma mensagem de erro teria sido emitida e não haveria compilação. Como o vetor foi declarado constante, a função Clear () não pôde operar, resultando em uma mensagem de erro do compilador.

Observação: claro () exclui todos os elementos do vetor. Na verdade, ele destaca todos os elementos excluídos, de modo que outros códigos possam adotar seus locais de memória. Se a localização da memória de qualquer elemento ainda não foi adotada por outro código, o elemento ainda poderá ser reutilizado em nome do mesmo vetor.

Apagação do vetor

As sintaxes simplificadas para as duas funções de membro EASE () são:

a.Apagar (Q)
e
a.Apagar (Q1, Q2)

onde a é o nome do vetor.

Erase do iterador (posição const_iterator)

Esta é a sintaxe completa para “a.apagar (q) ”. Ele retorna um iterador apontando para o elemento, que estava logo atrás do que apagou. O argumento, q é um iterador apontando para o elemento a ser apagado. O programa a seguir ilustra o seguinte:

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

vetor vtr = 'p', 'q', 'r', 's', 't', 'u';
vetor:: iterator iter = vtr.começar();
++iter; ++ iter;
vetor:: iterator it = vtr.apagar (iter);
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
retornar 0;

A saída é:

P q s t u
S

'R' foi excluído. O iterador devolvido agora aponta para 's', que foi logo após 'r'. A função do membro, BEGIN (), retorna um iterador que aponta para o primeiro elemento do vetor. No código, este iterador foi incrementado duas vezes para apontar para 'r'. 'R' foi apagado com a expressão, “VTR.apagar (iter) ”.

Alcance em vetor

Para a lista,

'P', 'q', 'r', 's', 't', 'u'

A sequência, 'q', 'r', 's', 't' é um intervalo. No entanto, com os recipientes C ++, o último elemento, 't' não é considerado parte do intervalo. Isso é indicado em termos gerais como:

[eu j)
ou
[Q1, Q2)

'[' neste caso, significa que o primeiro elemento na sequência está incluído e ')' significa que o último elemento não está incluído.

Erase do iterador (const_iterator primeiro, const_iterator Último)

Esta é a sintaxe completa para “a.Apagar (Q1, Q2) ”. Ele retorna um iterador apontando para o elemento, que estava logo atrás da faixa apagada. Nota: O último elemento no intervalo não é apagado. Então, o iterador retornado apontará para o último elemento do intervalo. Os argumentos Q1 e Q2 são iteradores apontando para o primeiro e o último elementos do intervalo. O programa a seguir ilustra o seguinte:

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

vetor vtr = 'p', 'q', 'r', 's', 't', 'u';
vetor:: iterator itb = vtr.começar();
++itb;
vetor:: iterator ite = vtr.fim();
--eu te; --eu te;
vetor:: iterator it = vtr.apagar (ITB, ITE);
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
retornar 0;

A saída é:

P t u
T

'Q', 'r', 's' foram excluídos. O iterador devolvido agora aponta para 't', que foi o último elemento no intervalo de contêineres. A função do membro, end (), retorna um iterador que aponta logo após o último elemento do vetor. No código, este iterador foi diminuído duas vezes para apontar para 't', o último elemento do intervalo. 'Q', 'r', 's' foi excluído sem o último elemento, 't' no intervalo, com a expressão: “VTR.Apagar (ITB, ITE) ”.

const vetor e apagar ()

Se a declaração de um vetor for precedida com const, para constante, então nenhum de seus elementos poderá ser apagado. O programa a seguir não será compilação, emitindo uma mensagem de erro para o a.ERASE (Q) Expressão:

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

const vetor vtr = 'p', 'q', 'r', 's', 't', 'u';
vetor:: const_iterator iter = vtr.começar();
++iter; ++ iter;
vetor:: const_iterator it = vtr.apagar (iter);
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
retornar 0;

Se o leitor tentasse o programa, ele teria recebido uma mensagem de erro. O programa não teria compilado.

O programa a seguir não será compilação, emitindo uma mensagem de erro para o a.ERASE (Q1, Q2) Expressão:

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

const vetor vtr = 'p', 'q', 'r', 's', 't', 'u';
vetor:: const_iterator itb = vtr.começar();
++itb;
vetor:: const_iterator ite = vtr.fim();
--eu te; --eu te;
vetor:: const_iterator it = vtr.apagar (ITB, ITE);
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
retornar 0;

Nota: EASE () exclui um elemento ou uma variedade de elementos. Na verdade, ele destaca um elemento excluído, de modo que seus locais de memória possam ser absorvidos por outros códigos. Se a localização da memória de qualquer elemento ainda não foi adotada por outro código, o elemento ainda poderá ser reutilizado em nome do mesmo vetor.

pop_back ()

A função Pop_back () Vector Member é uma espécie de função EASE (). No entanto, ele exclui apenas o último elemento do vetor. A sintaxe é:

void pop_back ()

Não leva argumento e retorna vazio. O programa a seguir ilustra seu uso:

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

vetor vtr = 'p', 'q', 'r', 's', 't', 'u';
vtr.pop_back ();
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
retornar 0;

A saída é:

P q r s t

O último elemento, 'u' foi removido (apagado).

Destruindo um vetor

Um vetor pode ser destruído? - Sim! No entanto, quando um vetor é destruído, todos os seus elementos são apagados, exceto seu nome; o que significa que a declaração do vetor ainda pode ser reutilizada, mas com alguma incerteza. A sintaxe para destruir um vetor é:

a.~ X ()

onde 'a' é o nome do vetor. O programa a seguir ilustra o seguinte:

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

vetor vtr = 'p', 'q', 'r', 's', 't', 'u';
vtr.~ vetor ();
vtr = 'v', 'w', 'x', 'y', 'z';
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
vtr.~ vetor ();
vtr.push_back ('a');
vtr.push_back ('b');
vtr.push_back ('c');
vtr.push_back ('d');
vtr.push_back ('e');
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
retornar 0;

A saída é:

V W X Y Z
p ^ t e @ a c d e

Do computador do autor, com alguns caracteres não confiáveis ​​para a segunda linha.

Conclusão

A função do membro vetorial Clear () pode ser comparada à função do membro vetorial EASE (). Eles não são substitutos. claro () exclui todos os elementos do vetor. Na verdade, ele destaca todos os elementos excluídos, de modo que seus locais de memória possam ser absorvidos por outros códigos. Se a localização da memória de qualquer elemento ainda não foi adotada por outro código, o elemento ainda poderá ser reutilizado em nome do mesmo vetor. EASE () exclui um elemento ou uma variedade de elementos. Na verdade, ele destaca um elemento excluído, de modo que o local da memória possa ser retomado por outro código. Se a localização da memória de qualquer elemento excluída ainda não foi adotada por outro código, o elemento ainda poderá ser reutilizado em nome do mesmo vetor. claro tem semelhança para destruir, ~ x ().