Você pode excluir um vetor em c++?

Sim! Sim, mas não vai sem restrições. Existem duas maneiras de excluir um vetor. Novamente eles não vão sem restrições. Uma maneira de excluir um vetor é usar o destruidor do vetor. Nesse caso, todos os elementos são excluídos, mas o nome do vetor não é excluído. A segunda maneira de excluir um vetor é apenas deixá -lo sair do escopo. Normalmente, qualquer objeto não estático declarado em um escopo morre quando sai do escopo. Isso significa que o objeto não pode ser acessado em um escopo de nidificação (bloco). Um escopo de nidificação é um escopo externo (bloco). Um escopo aninhado é um escopo interno, que ainda faz parte do escopo de interesse. Essas duas maneiras de excluir um vetor são discutidas neste artigo.

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

#incluir
#incluir
usando namespace std;

Conteúdo do artigo

• Destruindo o vetor
• Deixe sair do escopo
• Conclusão

Destruindo o vetor

Qualquer objeto criado está em algum escopo. O vetor é criado e destruído no escopo da função principal () nesta seção do artigo. A sintaxe para destruir um vetor é:

a.~ X ()

onde 'a' é o nome do vetor, e x é o nome da classe do vetor. O vetor é uma estrutura de dados instanciada de uma classe. O nome da classe vetorial é "vetor", com todos os personagens em minúsculas. Se o nome do vetor for VTR, então o vetor seria destruído,

vtr.~ vetor.

O programa a seguir exclui o vetor:

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

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

cout << endl;
retornar 0;

A saída não é nada, indicando que todos os elementos vetoriais, exceto o nome do vetor, foram apagados. Está bem. A saída acima foi exibida referenciando os supostos elementos. E se a saída for exibida usando o iterador? Considere o seguinte programa:

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

vetor vtr = 'a', 'b', 'c', 'd', 'e';
vetor:: iterator it = vtr.começar();
vtr.~ vetor ();
para (it = it; != vtr.fim(); It ++)
cout << *it << ";

cout << endl;
retornar 0;

A saída ainda não é nada. Nesta fase, é seguro concluir que quando um vetor é destruído, todos os seus elementos são destruídos, exceto seu nome.

Nome do vetor não destruído

Como o nome do vetor não é destruído com o destruidor, o nome ainda pode ser reutilizado no mesmo escopo. O programa a seguir ilustra o seguinte:

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

vetor vtr = 'a', 'b', 'c', 'd', 'e';
vtr.~ vetor ();
vtr = 'f', 'g', 'h', 'i', 'j';
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
retornar 0;

A saída é:

F g h i j

O conteúdo original do vetor tinha 5 caracteres. Os 5 elementos foram todos apagados. Como o nome do vetor foi reutilizado, novos 5 caracteres foram dados como conteúdo para o vetor. A saída mostrou o novo conteúdo para estar correto.

No entanto, ainda há uma nuance. Se o novo conteúdo for fornecido com a função de membro push_back (), a saída poderá estar incompleta e pode haver novos caracteres no vetor. O programa a seguir ilustra o seguinte:

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

vetor vtr = 'a', 'b', 'c', 'd', 'e';
vtr.~ vetor ();
vtr = 'v', 'w', 'x', 'y', 'z';
vtr.~ vetor ();
vtr.push_back ('f');
vtr.push_back ('g');
vtr.push_back ('h');
vtr.push_back ('i');
vtr.push_back ('j');
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
retornar 0;

A saída é:

p ^ t e u g h i j

'F' está faltando na saída, e há caracteres estranhos. Inicialmente, o conteúdo vetorial é fornecido usando o operador de atribuição. O vetor é destruído e novo conteúdo atribuído novamente com o operador de atribuição. O vetor é destruído novamente, e desta vez o conteúdo é fornecido com a função de membro push_back (). 'F' está faltando na saída, e há caracteres estranhos. Isso precisa de explicação:

Quando um vetor é destruído, todos os seus elementos são oficialmente apagados. O que acontece é que os elementos são simplesmente considerados não pertencem ao vetor com efeito imediato, e seus locais de memória são destinados como reutilizáveis ​​por qualquer outro código, com efeito imediato. Se esse esquema não for perfeitamente realizado internamente, como no último programa acima, haverá problemas, e o tipo de saída obtida acima pode resultar.

const vetor

Quando uma declaração de vetor é precedida por const, para constante, ela ainda pode ser destruída, como explicado acima. O programa a seguir ilustra o seguinte:

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

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

cout << endl;
retornar 0;

A saída não é nada. No entanto, sob essa condição (const vetor), nenhum elemento pode ser apagado usando a função de membro EASE ().

Usando o nome em um escopo aninhado

Destruir um vetor com ~ vetor destrói o conteúdo (elementos), mas não o nome do vetor. O nome ainda pode ser usado em um escopo interno, que ainda faz parte do escopo de interesse. O programa a seguir ilustra o seguinte:

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

vetor vtr = 'a', 'b', 'c', 'd', 'e';
vtr.~ vetor ();
if (1 == 1)
vtr = 'k', 'l', 'm', 'n', 'o';
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";
cout << endl;

retornar 0;

A saída é:

K l m n o

Nota: Se um nome de vetor for reutilizado, não deve ser re-declarado.

Deixe sair do escopo

Quando qualquer objeto declarado sai de seu escopo, ele não pode mais ser acessado de seu escopo. Isso significa que não pode mais ser acessado em um escopo de nidificação. No entanto, pode ser acessado em um escopo aninhado. Um escopo aninhado ainda faz parte do escopo em questão.

Acesso dentro e fora do escopo

O programa a seguir ilustra como um vetor é acessado em escopo:

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

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

retornar 0;

A saída é:

A B C D E

O escopo da função principal () ninhos no escopo do Block IF. VTR declarado no escopo do Block IF pode ser acessado apenas no escopo do IF-Block. Não pode ser acessado fora do escopo do IF-Block. Não pode ser acessado fora no bloco de funções principal () que ninho no bloco if. O programa a seguir não compilará, pois é feita uma tentativa de acessar o vetor fora de seu escopo:

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

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

cout << vtr[1] << endl;
retornar 0;

Se o leitor tentasse compilar o programa, uma mensagem de erro teria sido emitida.

Escopo aninhado

Um escopo aninhado ainda faz parte do escopo em questão. O programa a seguir ilustra como um vetor pode ser acessado em um escopo aninhado:

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

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


retornar 0;

A saída é:

A B C D E

O bloqueio de função principal () ninhos no primeiro Block IF, que aninha o segundo IF-Block. O vetor é declarado no primeiro IF Block. Foi acessado no aninhado (interno) se block.

A abordagem de deixar o vetor morrer à medida que sai do escopo parece preferível em comparação com o uso do destruidor. Quando o vetor sai do escopo, seu nome também morre. No entanto, não é o tempo todo que o programador deseja que o vetor morresse saindo do escopo. Então o destruidor terá que ser usado ocasionalmente. Ambos os caminhos têm suas restrições.

Conclusão

Uma maneira de excluir um vetor é usar o destruidor do vetor. Nesse caso, todos os elementos são excluídos, mas o nome do vetor não é excluído. A segunda maneira de excluir um vetor é apenas deixá -lo sair do escopo. Normalmente, qualquer objeto não estático declarado em um escopo morre quando sai do escopo. Isso significa que o objeto não pode ser acessado em um escopo de nidificação (bloco). Um escopo de nidificação é um escopo externo (bloco). No entanto, pode ser acessado em um escopo aninhado. Um escopo aninhado é um escopo interno, que ainda faz parte do escopo de interesse. Ambos os lados têm restrições. Um vetor em um escopo interno não precisa ser destruído com ~ vetor antes de deixá -lo sair do escopo para morrer.