Hvordan fjerner jeg et spesifikt element fra en vektor i C++?

C ++ -vektoren har mange medlemsfunksjoner. To av disse medlemsfunksjonene er slette () og pop_back (). pop_back () fjerner det siste elementet fra vektoren. For å fjerne alle elementene fra vektoren, ved hjelp av pop_back (), må POP_BACK () -funksjonen gjentas antall ganger det er elementer. Sletting () -funksjonen kan fjerne et element fra begynnelsen, innenfor eller slutten av vektoren. For å fjerne alle elementene fra vektoren, ved hjelp av sletting (), må sletting () -funksjonen gjentas antall ganger det er elementer, fra det første elementet.

For å fjerne et spesifikt element fra C ++ -vektoren, må elementet identifiseres. Når det gjelder slett () medlemsfunksjon, identifiseres elementet av en iterator. Det neste spørsmålet er: “Hva er en iterator?” - Se nedenfor. Siden POP_BACK () medlemsfunksjonen fjerner det siste elementet per definisjon, har det spesifikke elementet det må fjerne allerede blitt identifisert indirekte.

For å bruke vektorbiblioteket i C ++, må programmet begynne med:

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

Denne artikkelen forklarer hvordan du fjerner et spesifikt element fra C ++ -vektoren, som begynner med å forklare den viktigste iteratoren i C++. All vektorkode for denne artikkelen er i hovedkroppen ().

Artikkelinnhold

• INNLEDNING - Se ovenfor
• Identifisere vektorelement
• Fjerne med sletting ()
• Fjerner med pop_back
• Konklusjon

Identifisere vektorelement

Identifisere med referanse
Tenk på følgende vektor:

vektor vtr = 'a', 'b', 'c', 'd', 'e';

VTR [0] returnerer 'A'. VTR [1] Returnerer 'B'. VTR [2] Returnerer 'C'. VTR [3] Returnerer 'D'. VTR [4] Returnerer 'E'. Dette identifiserer seg ved referanse. Antallet i firkantede parenteser, kalles en indeks. Det kan gjøres i en for-loop, som følgende program viser:

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

vektor vtr = 'a', 'b', 'c', 'd', 'e';
for (int i = 0; icout << vtr[i] << ";
cout << endl;
retur 0;

Utgangen er:

A B C D E

Identifisering av iterator
Tenk på følgende vektor:

vektor vtr = 'a', 'b', 'c', 'd', 'e';

det = vtr.Begynn (), betyr 'det' er en iterator som peker på 'a' .

det ++ peker på 'b'.

Den ++ peker på 'C', økt etter at den pekte på 'B'.

Den ++ peker på 'D', økt etter at den pekte på 'C'.

Den ++ peker på 'E', økt etter at den pekte på 'D'.

det ++ peker på VTR.slutt (), som er rett utenfor det siste elementet, økt etter å ha pekt på 'e'.

Dette kan gjøres i en for-loop, som følgende program viser:

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

vektor vtr = 'a', 'b', 'c', 'd', 'e';
for (vektor :: iterator it = vtr.begynne(); den != VTR.slutt(); det ++)
cout << *it << ";
cout << endl;
retur 0;

Utgangen er:

A B C D E

Den første iteratoren ble fått med erklæringen:

vektor :: iterator it

hvor 'det' er identifikatoren til iteratoren.

Refererer fortsatt til den samme vektoren,

det = vtr.slutt (), peker rett utenfor det siste elementet 'e' .

det- peker på 'e'.

Det peker på 'D', dekrementert etter at det pekte på 'e'.

Det peker på 'C', dekrementert etter at det pekte på 'D'.

Det peker på 'B', redusert etter at det pekte på 'C'.

Det peker på 'A', dekrementert etter at det pekte på 'B'.

Dette skjemaet kan brukes til å vise vektoren i omvendt rekkefølge, som følgende program viser:

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

vektor vtr = 'a', 'b', 'c', 'd', 'e';
vektor :: iterator it = vtr.slutt();
for (det = -det; det> = VTR.begynne(); den--)
cout << *it << ";
cout << endl;
retur 0;

Utgangen er:

E D C B A

Den første iteratoren for for-loopen er dekrementert. Jeg.e. "Det = -it;". Legg merke til mens-betingelsen for for-loop, jeg.e. “Det> = VTR.begynne();".

For å oppnå verdien som iteratoren peker på, må iteratoren bli henvenert av indireksjonsoperatøren, *.

Fjerne med sletting ()

Syntaksen for å slette (fjerne) et element fra en vektor er:

en.Slett (q)

hvor 'a' er vektorens navn, og Q er en iterator som peker på elementet som skal fjernes. Det vil si at Q identifiserer det spesifikke elementet som skal fjernes. Medlemsfunksjonen returnerer en iterator som peker på elementet like etter at den er fjernet.

Fjerner fra fronten
Slette medlemsfunksjonen kan fjerne et element fra fronten av vektoren. Følgende program illustrerer dette:

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

vektor vtr = 'a', 'b', 'c', 'd', 'e';
vektor :: iterator q = vtr.begynne();
vektor :: iterator p = vtr.slette (q);
cout << *p << endl;
for (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";
cout << endl;
for (vektor :: iterator it = vtr.begynne(); den != VTR.slutt(); det ++)
cout << *it << ";
cout << endl;
retur 0;

Utgangen er:

B
B C D E
B C D E

De to første linjene i programmet inkluderer direktiver, inkludert nødvendige biblioteker. Den neste linjen erklærer at ethvert navn som brukes er fra standard navneområde med mindre annet er angitt.

I hovedfunksjonen () erklærer den første uttalelsen vektoren. Uttalelsen etter returnerer en iterator, Q, som peker på det første elementet i vektoren. Uttalelsen som følger er erklæringen av interesse. Det fjerner det første elementet, som er pekt på av Q. Den returnerer en iterator som peker på elementet, som var like etter at elementet ble fjernet. Uttalelsen etter skriver ut verdien av elementet iteratoren peker på etter fjerning. De to neste kodesegmentene viser de gjenværende verdiene i vektoren. Den første av disse kodesegmentene bruker referanser. Den andre bruker iteratorer.

Fjerne innenfra
For å fjerne verdieneselementet, 'C', må iteratoren returnert, ved å begynne () økes to ganger for å peke på verdienes element, 'C'. Slett () medlemsfunksjon kan deretter bruke iteratoren til å fjerne elementet. Følgende program illustrerer dette:

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

vektor vtr = 'a', 'b', 'c', 'd', 'e';
vektor :: iterator q = vtr.begynne();
Q ++; Q ++;
vektor :: iterator p = vtr.slette (q);
cout << *p << endl;
for (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";
cout << endl;
for (vektor :: iterator it = vtr.begynne(); den != VTR.slutt(); det ++)
cout << *it << ";
cout << endl;
retur 0;

Utgangen er:

D
A b d e
A b d e

Fjerne fra ryggen med sletting ()
For å fjerne verdienes element, 'e', ​​må iteratoren returnert, ved slutten () å reduseres en gang, for å peke på verdien av verdien, 'e'. Slett () medlemsfunksjon kan deretter bruke iteratoren til å fjerne elementet. Følgende program illustrerer dette:

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

vektor vtr = 'a', 'b', 'c', 'd', 'e';
vektor :: iterator q = vtr.slutt();
Q--;
vektor :: iterator p = vtr.slette (q);
cout << *p << endl;
for (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";
cout << endl;
for (vektor :: iterator it = vtr.begynne(); den != VTR.slutt(); det ++)
cout << *it << ";
cout << endl;
retur 0;

Utgangen er:

E
A B C D
A B C D

Det er en nyanse her. Iteratoren returnert etter ende () peker på elementet, som burde vært der, hadde det ikke blitt fjernet.

Fjerner med pop_back

Pop_back () medlemsfunksjonen fjerner det siste elementet i vektoren, per definisjon. Så programmereren trenger ikke å identifisere det siste elementet. Syntaks er

en.pop_back ()

hvor 'a' er navnet på vektoren. Det krever ingen argumenter; det returnerer tomrom. Følgende program fjerner det siste elementet i en vektor:

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

vektor vtr = 'a', 'b', 'c', 'd', 'e';
VTR.pop_back ();
for (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";
cout << endl;
for (vektor :: iterator it = vtr.begynne(); den != VTR.slutt(); det ++)
cout << *it << ";
cout << endl;
retur 0;

Utgangen er:

A B C D
A B C D

Konklusjon

C ++ -vektoren har mange medlemsfunksjoner. To av disse medlemsfunksjonene er slette () og pop_back (). pop_back () fjerner det siste elementet fra vektoren. For å fjerne alle elementene fra vektoren, ved hjelp av pop_back (), må POP_BACK () -funksjonen gjentas antall ganger det er elementer. Sletting () -funksjonen kan fjerne et element fra begynnelsen, innenfor eller slutten av vektoren. For å fjerne alle elementene fra vektoren, ved hjelp av sletting (), må sletting () -funksjonen gjentas antall ganger det er elementer, fra det første elementet.

For å fjerne et spesifikt element fra C ++ -vektoren, må elementet identifiseres. For slett () medlemsfunksjon identifiseres elementet av en iterator. Siden POP_BACK () medlemsfunksjonen fjerner det siste elementet per definisjon, har det spesifikke elementet det må fjerne allerede blitt identifisert indirekte.