Puoi eliminare un vettore in c++?

SÌ! Sì, ma non va senza vincoli. Esistono due modi per eliminare un vettore. Ancora una volta non vanno senza vincoli. Un modo per eliminare un vettore è usare il distruttore del vettore. In questo caso, tutti gli elementi vengono eliminati, ma il nome del vettore non viene eliminato. Il secondo modo per eliminare un vettore è solo per lasciarlo andare fuori portata. Normalmente, qualsiasi oggetto non statico dichiarato in un ambito muore quando esce dall'ambito. Ciò significa che non è possibile accedere all'oggetto in un ambito di nidificazione (blocco). Un ambito di nidificazione è un ambito esterno (blocco). Un ambito nidificato è un ambito interiore, che fa ancora parte dell'ambito di interesse. Questi due modi di eliminare un vettore sono discussi in questo articolo.

Per utilizzare un vettore in C ++, il programma dovrebbe iniziare con:

#includere
#includere
Utilizzo dello spazio dei nomi std;

Contenuto dell'articolo

• Distruggere il vettore
• Lascia andare fuori dall'ambito
• Conclusione

Distruggere il vettore

Qualsiasi oggetto creato è in qualche modo. Il vettore viene creato e distrutto nell'ambito della funzione principale () in questa sezione dell'articolo. La sintassi per distruggere un vettore è:

UN.~ X ()

dove "a" è il nome del vettore e x è il nome di classe del vettore. Il vettore è una struttura di dati istanziata da una classe. Il nome della classe vettoriale è "vettoriale", con tutti i caratteri in minuscolo. Se il nome del vettore è VTR, allora il vettore sarebbe distrutto,

VTR.~ Vector.

Il seguente programma elimina il vettore:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

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

cout << endl;
restituzione 0;

L'output non è nulla, indicando che tutti gli elementi vettoriali, tranne il nome del vettore, sono stati cancellati. Questo va bene. L'output sopra è stato visualizzato facendo riferimento ai presunti elementi. Cosa succede se l'uscita viene visualizzata usando l'iteratore? Considera il seguente programma:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

vettore vtr = 'a', 'b', 'c', 'd', 'e';
vettore:: iterator it = vtr.inizio();
VTR.~ vector ();
per (esso = esso; != vtr.FINE(); it ++)
cout << *it << ";

cout << endl;
restituzione 0;

L'output non è ancora niente. In questa fase, è sicuro concludere che quando un vettore viene distrutto, tutti i suoi elementi vengono distrutti, tranne il suo nome.

Nome vettoriale non distrutto

Poiché il nome vettoriale non viene distrutto con il distruttore, il nome può ancora essere riutilizzato nello stesso ambito. Il seguente programma illustra questo:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

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

cout << endl;
restituzione 0;

L'output è:

F g h i j

Il contenuto originale del vettore aveva 5 caratteri. I 5 elementi sono stati tutti cancellati. Poiché il nome vettoriale è stato riutilizzato, sono stati dati nuovi 5 caratteri come contenuto al vettore. L'output ha mostrato che il nuovo contenuto è corretto.

Tuttavia, c'è ancora una sfumatura. Se il nuovo contenuto viene fornito con la funzione membro push_back (), l'output può essere incompleto e potrebbero esserci nuovi caratteri nel vettore. Il seguente programma illustra questo:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

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

cout << endl;
restituzione 0;

L'output è:

p ^ t e u g h i j

'F' manca nell'output e ci sono strani personaggi. Inizialmente, il contenuto vettoriale viene fornito utilizzando l'operatore di assegnazione. Il vettore viene distrutto e nuovi contenuti assegnati con l'operatore di assegnazione. Il vettore viene nuovamente distrutto e questa volta il contenuto viene dato con la funzione membro push_back (). 'F' manca nell'output e ci sono strani personaggi. Questo ha bisogno di una spiegazione:

Quando un vettore viene distrutto, tutti i suoi elementi vengono cancellati ufficialmente. Ciò che accade è che gli elementi sono semplicemente considerati di non appartenere al vettore con effetto immediato e le loro posizioni di memoria sono destinate come riutilizzabili da qualsiasi altro codice, con effetto immediato. Se questo schema non viene eseguito perfettamente internamente, come con l'ultimo programma sopra, allora ci sarà problemi e il tipo di output ottenuto sopra può derivare.

const vector

Quando una dichiarazione vettoriale è preceduta da const, per costante, può ancora essere distrutta, come spiegato sopra. Il seguente programma illustra questo:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

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

cout << endl;
restituzione 0;

L'output non è niente. Tuttavia, in questa condizione (const vector), nessun elemento può essere cancellato utilizzando la funzione membro Cerase ().

Usando il nome in un ambito nidificato

Distruggere un vettore con ~ vettoriale distrugge il contenuto (elementi) ma non il nome vettoriale. Il nome può ancora essere usato in un ambito interno, che fa ancora parte dell'ambito di interesse. Il seguente programma illustra questo:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

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

restituzione 0;

L'output è:

K l m n o

Nota: se un nome vettoriale deve essere riutilizzato, non dovrebbe essere riclacariato.

Lascia andare fuori dall'ambito

Quando qualsiasi oggetto dichiarato esce dal suo ambito, non è più possibile accedervi dal suo ambito. Ciò significa che non è più possibile accedere a un ambito di nidificazione. Tuttavia, è possibile accedere a un ambito nidificato. Un ambito nidificato fa ancora parte dell'ambito in questione.

Accesso dentro e fuori dalla portata

Il seguente programma illustra come si accede a un vettore nell'ambito:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

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

restituzione 0;

L'output è:

A b c d e

L'ambito di funzione principale () nidifica l'ambito IF-Block. È possibile accedere a VTR nell'ambito IF-Block solo nell'ambito IF-Block. Non è possibile accedervi al di fuori dell'ambito If-Block. Non è possibile accedere all'esterno nel blocco funzione principale () che nidifica il blocco if. Il seguente programma non si compilerà, poiché viene fatto un tentativo di accedere al vettore al di fuori del suo ambito:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

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

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

Se il lettore provasse a compilare il programma, sarebbe stato emesso un messaggio di errore.

Portata nidificata

Un ambito nidificato fa ancora parte dell'ambito in questione. Il seguente programma illustra come è possibile accedere a un vettore in un ambito nidificato:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

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


restituzione 0;

L'output è:

A b c d e

La funzione principale () blocca nidifica il primo If-Block, che nidifica il secondo if-block. Il vettore è dichiarato nel primo If Block. È stato accessibile nel nidificato (interno) if-block.

L'approccio di lasciare morire il vettore mentre esce dall'ambito sembra preferibile rispetto all'uso del distruttore. Quando il vettore esce dall'ambito, il suo nome muore anche. Tuttavia, non è sempre che il programmatore vorrebbe che il vettore muoia andando fuori portata. Quindi il distruttore dovrà essere usato occasionalmente. Entrambi i modi hanno i loro vincoli.

Conclusione

Un modo per eliminare un vettore è usare il distruttore del vettore. In questo caso, tutti gli elementi vengono eliminati, ma il nome del vettore non viene eliminato. Il secondo modo per eliminare un vettore è solo per lasciarlo andare fuori portata. Normalmente, qualsiasi oggetto non statico dichiarato in un ambito muore quando esce dall'ambito. Ciò significa che non è possibile accedere all'oggetto in un ambito di nidificazione (blocco). Un ambito di nidificazione è un ambito esterno (blocco). Tuttavia, è possibile accedere a un ambito nidificato. Un ambito nidificato è un ambito interiore, che fa ancora parte dell'ambito di interesse. Entrambi i modi hanno vincoli. Un vettore in un ambito interno non ha bisogno di essere distrutto con ~ vettore prima di lasciarlo andare fuori dalla portata per morire.