C ++ vektorklar vs slette

C ++ -vektoren har mange medlemsfunksjoner. To av dem er klar () og slette (). klar() “Fjerner” alle elementene i vektoren. Slett () "fjerner" et enkelt element eller et utvalg av elementer. Det er to overbelastede varianter av slette () medlemsfunksjon for vektoren.

Tittelen på denne artikkelen er faktisk “Vector Clear () Member Function Versus Vector Erase () Medlemsfunksjon, i C ++”. Dette er en sammenligning av funksjonene med to medlemmer. Den omhandler når du skal bruke hvilke, hvordan du bruker hvilke og under hvilke forhold enten brukes.

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

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

Artikkelinnhold

• Vektorklar ()
• Vektor Sletting
• Pop_back
• Ødelegger en vektor
• Konklusjon

Vektorklar ()

Den klare () medlemsfunksjonen "fjerner" alle elementene i vektoren. Syntaks er:

ugyldig klar ()

Det returnerer tomrom. Følgende program illustrerer bruken, med uttrykket, “VTR.klar();":

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

vektor vtr = 'p', 'q', 'r', 's', 't', 'u';
for (vektor:: Iterator IT = VTR.begynne(); den != VTR.slutt(); det ++)
cout << *it << ";
cout << endl;
VTR.klar();
for (vektor:: Iterator IT = VTR.begynne(); den != VTR.slutt(); det ++)
cout << *it << ";
cout << endl;
retur 0;

Utgangen er den ene linjen:

P q r s t u

Hvis vektoren ikke hadde blitt fjernet, ville utgangen vært to linjer i samme sekvens. Ingen andre linje ble vist fordi alle elementene ble fjernet.

Const Vector and Clear ()

Når en vektorerklæring er gitt av Const, betyr det at elementene i vektoren ikke kan slettes eller endres. Hvis et uttrykk prøver å endre eller slette noen av elementene, vil ikke programmet sammenstille. Test følgende program og legg merke til at det ikke sammenstiller:

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

const vektor vtr = 'p', 'q', 'r', 's', 't', 'u';
for (vektor:: const_iterator it = VTR.begynne(); den != VTR.slutt(); det ++)
cout << *it << ";
cout << endl;
VTR.klar();
for (vektor:: const_iterator it = VTR.begynne(); den != VTR.slutt(); det ++)
cout << *it << ";
cout << endl;
retur 0;

Hvis programmet ble testet, ville en feilmelding blitt utstedt, og det ville ikke vært noen samling. Fordi vektoren ble erklært konstant, kunne ikke klart () funksjonen fungere, noe som resulterte i en feilmelding fra kompilatoren.

Merk: klar () sletter alle elementene i vektoren. Egentlig øremerker det alle elementene som slettet, slik at andre koder kan ta opp minneplassene sine. Hvis minneplassen til noe element ennå ikke er tatt opp av en annen kode, kan elementet fremdeles gjenbrukes på vegne av samme vektor.

Vektor Sletting

De forenklede syntaksene for de to slette () medlemsfunksjonene er:

en.Slett (q)
og
en.Sletting (Q1, Q2)

hvor a er navnet på vektoren.

iterator erase (const_iterator posisjon)

Dette er full syntaks for “a.Slett (q) ”. Den returnerer en iterator som peker på elementet, som var like bak den som er slettet. Argumentet, Q er en iterator som peker på elementet som skal slettes. Følgende program illustrerer dette:

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

vektor vtr = 'p', 'q', 'r', 's', 't', 'u';
vektor:: iterator iter = VTR.begynne();
++iter; ++ iter;
vektor:: Iterator IT = VTR.slette (iter);
for (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
retur 0;

Utgangen er:

P q s t u
S

'R' er slettet. Den returnerte iteratoren peker nå til 'S', som var like etter 'R'. Medlemsfunksjonen, begynn (), returnerer en iterator som peker på det første elementet i vektoren. I koden ble denne iteratoren økt to ganger for å peke på 'r'. 'R' ble slettet med uttrykket, “VTR.Slett (iter) ”.

Rekkevidde i vektor

For listen,

'P', 'Q', 'r', 'S', 'T', 'U'

sekvensen, 'q', 'r', 's', 't' er et område. Imidlertid, med C ++ containere, regnes det siste elementet, 't' ikke som en del av området. Dette indikeres generelt som:

[i, j)
eller
[Q1, Q2)

'[' I dette tilfellet, betyr det at det første elementet i sekvensen er inkludert, og ')' betyr at det siste elementet ikke er inkludert.

iterator erase (const_iterator først, const_iterator sist)

Dette er full syntaks for “a.Slett (Q1, Q2) ”. Den returnerer en iterator som peker på elementet, som var like bak rekkevidden slettet. Merk: Det siste elementet i området er ikke slettet. Så den returnerte iteratoren vil peke på det siste elementet i området. Argumentene Q1and Q2 er iteratorer som peker på de første og siste elementene i området. Følgende program illustrerer dette:

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

vektor vtr = 'p', 'q', 'r', 's', 't', 'u';
vektor:: Iterator ITB = VTR.begynne();
++itb;
vektor:: iterator ite = VTR.slutt();
--ite; --It;
vektor:: Iterator IT = VTR.slette (itb, ite);
for (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
retur 0;

Utgangen er:

P t u
T

'Q', 'r', 's' er blitt slettet. Den returnerte iteratoren peker nå til 'T', som var det siste elementet i containerområdet. Medlemsfunksjonen, end (), returnerer en iterator som peker rett etter det siste elementet i vektoren. I koden ble denne iteratoren dekrementert to ganger for å peke på 'T', det siste elementet i området. 'Q', 'r', 's' ble slettet uten det siste elementet, 't' i området, med uttrykket, "VTR.Slett (ITB, ITE) ”.

const vektor og slette ()

Hvis erklæringen om en vektor er foran med Const, for konstant, kan ingen av dens elementer slettes. Følgende program vil ikke sammenstille, gi ut en feilmelding for a.Slett (q) uttrykk:

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

const vektor vtr = 'p', 'q', 'r', 's', 't', 'u';
vektor:: const_iterator iter = vtr.begynne();
++iter; ++ iter;
vektor:: const_iterator it = VTR.slette (iter);
for (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
retur 0;

Hvis leseren prøvde programmet, ville han ha mottatt en feilmelding. Programmet ville ikke ha samlet.

Følgende program vil ikke sammenstille, gi ut en feilmelding for a.Slett (Q1, Q2) uttrykk:

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

const vektor vtr = 'p', 'q', 'r', 's', 't', 'u';
vektor:: const_iterator itb = vtr.begynne();
++itb;
vektor:: const_iterator ite = vtr.slutt();
--ite; --It;
vektor:: const_iterator it = VTR.slette (itb, ite);
for (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
retur 0;

Merk: Slett () sletter et element eller en rekke elementer. Egentlig øremerker det et element som slettet, slik at minneplasseringene deres kan tas opp av andre koder. Hvis minneplassen til noe element ennå ikke er tatt opp av en annen kode, kan elementet fremdeles gjenbrukes på vegne av samme vektor.

pop_back ()

POP_BACK () Vector Member -funksjonen er en slags sletting () -funksjon. Imidlertid sletter den bare det siste elementet i vektoren. Syntaksen er:

ugyldig pop_back ()

Det krever ikke noe argument og returnerer tomrom. Følgende program illustrerer bruken:

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

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

cout << endl;
retur 0;

Utgangen er:

P q r s t

Det siste elementet, 'U' er fjernet (slettet).

Ødelegger en vektor

Kan en vektor bli ødelagt? - Ja! Imidlertid, når en vektor blir ødelagt, blir alle dens elementer slettet bortsett fra navnet; noe som betyr at vektorerklæringen fortsatt kan brukes på nytt, men med litt usikkerhet. Syntaksen for å ødelegge en vektor er:

en.~ X ()

hvor 'a' er navnet på vektoren. Følgende program illustrerer dette:

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

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

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

cout << endl;
retur 0;

Utgangen er:

V w x y z
p ^ t e @ a c d e

fra forfatterens datamaskin, med noen upålitelige karakterer for den andre linjen.

Konklusjon

Vektormedlemsfunksjonen Clear () kan sammenlignes med Vector Member Function Erase (). De er ikke erstatning. klar () sletter alle elementene i vektoren. Egentlig øremerker det alle elementene som slettet, slik at minneplasseringene deres kan tas opp av andre koder. Hvis minneplassen til noe element ennå ikke er tatt opp av en annen kode, kan elementet fremdeles gjenbrukes på vegne av samme vektor. Slett () sletter et element eller en rekke elementer. Egentlig øremerker det et element som slettet, slik at minneplassen kan tas opp med en annen kode. Hvis minneplasseringen for et hvilket som helst element som er slettet ennå ikke er tatt opp av en annen kode, kan elementet fremdeles gjenbrukes på vegne av samme vektor. klar har likhet med å ødelegge, ~ x ().