Kan du slette en vektor i C++?

Ja! Ja, men det går ikke uten begrensninger. Det er to måter å slette en vektor på. Igjen går de ikke uten begrensninger. En måte å slette en vektor på er å bruke ødeleggeren til vektoren. I dette tilfellet blir alle elementene slettet, men navnet på vektoren blir ikke slettet. Den andre måten å slette en vektor er bare å la den gå ut av omfang. Normalt dør ethvert ikke-statisk objekt som er erklært i et omfang når det går ut av omfang. Dette betyr at objektet ikke kan nås i et hekkeomfang (blokk). Et hekkomfang er et ytre omfang (blokk). Et nestet omfang er et indre omfang, som fremdeles er en del av omfanget av interesse. Disse to måtene å slette en vektor er diskutert i denne artikkelen.

For å bruke en vektor i C ++, bør programmet begynne med:

#inkludere
#inkludere
ved hjelp av navneområdet STD;

Artikkelinnhold

• Ødelegger vektoren
• La gå ut av omfang
• Konklusjon

Ødelegger vektoren

Ethvert objekt som er opprettet er i et eller annet omfang. Vektoren er opprettet og ødelagt i hovedfunksjonen for hoved () i denne delen av artikkelen. Syntaksen for å ødelegge en vektor er:

en.~ X ()

hvor 'a' er navnet på vektoren, og x er klassenavnet på vektoren. Vektoren er en datastruktur instantiert fra en klasse. Navnet på vektorklassen er "vektor", med alle tegn i små bokstaver. Hvis navnet på vektoren er VTR, ville vektoren bli ødelagt med,

VTR.~ vektor.

Følgende program sletter vektoren:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

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

cout << endl;
retur 0;

Utgangen er ingenting, noe som indikerer at alle vektorelementene, bortsett fra navnet på vektoren, er blitt slettet. Det er greit. Ovennevnte utgang ble vist ved å referere til de antatte elementene. Hva om utgangen vises ved hjelp av iteratoren? Tenk på følgende program:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

vektor vtr = 'a', 'b', 'c', 'd', 'e';
vektor:: Iterator IT = VTR.begynne();
VTR.~ vektor ();
for (det = det; det != VTR.slutt(); det ++)
cout << *it << ";

cout << endl;
retur 0;

Utgangen er fremdeles ingenting. På dette stadiet er det trygt å virkelig konkludere med at når en vektor blir ødelagt, blir alle dens elementer ødelagt, bortsett fra navnet.

Vektornavn ikke ødelagt

Siden vektortavnet ikke blir ødelagt med destruktøren, kan navnet fremdeles gjenbrukes i samme omfang. Følgende program illustrerer dette:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

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

cout << endl;
retur 0;

Utgangen er:

F g h i j

Det originale innholdet i vektoren hadde 5 tegn. De 5 elementene ble alle slettet. Ettersom vektortavnet ble gjenbrukt, ble nye 5 tegn gitt som innhold til vektoren. Utgangen viste at det nye innholdet var riktig.

Imidlertid er det fortsatt en nyanse. Hvis det nye innholdet er gitt med Push_back () medlemsfunksjonen, kan utgangen være ufullstendig, og det kan være nye tegn i vektoren. Følgende program illustrerer dette:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

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

cout << endl;
retur 0;

Utgangen er:

p ^ t e u g h i j

'F' mangler i utgangen, og det er rare tegn. Opprinnelig blir vektorinnholdet gitt ved hjelp av tildelingsoperatøren. Vektoren blir ødelagt og nytt innhold som er tilordnet igjen med tildelingsoperatøren. Vektoren blir ødelagt igjen, og denne gangen er innholdet gitt med Push_back () medlemsfunksjonen. 'F' mangler i utgangen, og det er rare tegn. Dette trenger forklaring:

Når en vektor blir ødelagt, blir alle elementene offisielt slettet. Det som skjer er at elementene ganske enkelt anses å ikke tilhøre vektoren med øyeblikkelig virkning, og deres minneplasser er øremerket som gjenbrukbare av noen annen kode, med øyeblikkelig virkning. Hvis denne ordningen ikke utføres perfekt internt, som med det siste programmet ovenfor, vil det være problemer, og den typen output som er oppnådd ovenfor kan føre til.

const vektor

Når en vektorerklæring er gitt av Const, kan den fortsatt bli ødelagt, som forklart ovenfor. Følgende program illustrerer dette:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

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

cout << endl;
retur 0;

Utgangen er ingenting. Under denne tilstanden (Const Vector) kan imidlertid ikke noe element slettes ved hjelp av slettingsmedlemmets funksjonsfunksjon ().

Bruker navnet i et nestet omfang

Å ødelegge en vektor med ~ vektor ødelegger innholdet (elementer), men ikke vektortavnet. Navnet kan fremdeles brukes i et indre omfang, som fremdeles er en del av omfanget av interesse. Følgende program illustrerer dette:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

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

retur 0;

Utgangen er:

K l m n o

Merk: Hvis et vektortavn skal brukes på nytt, bør det ikke bli avklæres.

La gå ut av omfang

Når ethvert deklarert objekt går ut av omfanget, kan det ikke lenger nås ut av omfanget. Dette betyr at det ikke lenger kan nås i et hekkeomfang. Imidlertid kan det nås i et nestet omfang. Et nestet omfang er fremdeles en del av det aktuelle omfanget.

Tilgang inn og ut av omfang

Følgende program illustrerer hvordan en vektor er tilgjengelig i omfang:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

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

retur 0;

Utgangen er:

A B C D E

Hoved () funksjonsomfanget hekker if-block-omfanget. VTR erklært i IF-Block Scope kan nås bare i IF-Block-omfanget. Det kan ikke nås utenfor IF-Block-omfanget. Det kan ikke nås utenfor i hovedfunksjonsblokken () som hekker if-blokken. Følgende program vil ikke sammenstille, ettersom det blir gjort et forsøk på å få tilgang til vektoren utenfor omfanget:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

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

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

Hvis leseren prøvde å kompilere programmet, ville det blitt utstedt en feilmelding.

Nestet omfang

Et nestet omfang er fremdeles en del av det aktuelle omfanget. Følgende program illustrerer hvordan en vektor kan nås i et nestet omfang:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

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


retur 0;

Utgangen er:

A B C D E

Hovedfunksjonen () -funksjonen hekker den første if-block, som hekker den andre if-block. Vektoren er deklarert i første IF-blokk. Det har blitt åpnet i nestede (indre) if-block.

Tilnærmingen til å la vektoren dø når den går ut av omfanget ser ut, sammenlignet med å bruke destruktøren. Når vektoren går ut av omfang, dør navnet også. Imidlertid er det ikke hele tiden at programmereren ønsker at vektoren skal dø ved å gå ut av omfang. Så destruktøren må brukes innimellom. Begge veier har sine begrensninger.

Konklusjon

En måte å slette en vektor på er å bruke ødeleggeren til vektoren. I dette tilfellet blir alle elementene slettet, men navnet på vektoren blir ikke slettet. Den andre måten å slette en vektor er bare å la den gå ut av omfang. Normalt dør ethvert ikke-statisk objekt som er erklært i et omfang når det går ut av omfang. Dette betyr at objektet ikke kan nås i et hekkeomfang (blokk). Et hekkomfang er et ytre omfang (blokk). Imidlertid kan det nås i et nestet omfang. Et nestet omfang er et indre omfang, som fremdeles er en del av omfanget av interesse. Begge måter har begrensninger. En vektor i et indre omfang trenger ikke å bli ødelagt med ~ vektor før han lar den gå ut av omfanget til å dø.