C++ Vector Clear vs Erase

C Vector Clear Vs Erase



C++-vektoren har mange medlemsfunksjoner. To av dem er clear() og erase(). klar() 'fjerner' alle elementene i vektoren. erase() 'fjerner' et enkelt element eller en rekke elementer. Det er to overbelastede varianter av erase()-medlemsfunksjonen for vektoren.

Tittelen på denne artikkelen er faktisk 'Vector clear() Member Function versus Vector Erase() Member Function, in C++'. Dette er en sammenligning av to-leddets funksjoner. Den tar for seg når du skal bruke hvilken, hvordan du bruker hvilken, og under hvilke forhold enten brukes.







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



#inkluder

#include

ved hjelp av navneområde std ;

Artikkelinnhold

Vector clear()

Clear()-medlemsfunksjonen 'fjerner' alle elementene i vektoren. Syntaksen er:



tomrom klar ( )

Den returnerer ugyldig. Følgende program illustrerer bruken med uttrykket 'vtr.clear();':





#inkluder

#include

ved hjelp av navneområde std ;



int hoved- ( )

{

vektor < røye > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'I' } ;



til ( vektor < røye > :: iterator den = vtr. begynne ( ) ; den ! = vtr. slutt ( ) ; den ++ )

cout << * den << ' ' ;

cout << endl ;



vtr. klar ( ) ;



til ( vektor < røye > :: iterator den = vtr. begynne ( ) ; den ! = vtr. slutt ( ) ; den ++ )

cout << * den << ' ' ;

cout << endl ;



komme tilbake 0 ;

}

Utgangen er den ene linjen:

P Q R S T U

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



const vektor og klar()

Når en vektorerklæring innledes med const, betyr det at elementene i vektoren ikke kan slettes eller endres. Hvis et uttrykk forsøker å endre eller slette noen av elementene, vil ikke programmet kompilere. Test følgende program og merk at det ikke kompilerer:

#inkluder

#include

ved hjelp av navneområde std ;



int hoved- ( )

{

konst vektor < røye > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'I' } ;



til ( vektor < røye > :: const_iterator den = vtr. begynne ( ) ; den ! = vtr. slutt ( ) ; den ++ )

cout << * den << ' ' ;

cout << endl ;



vtr. klar ( ) ;



til ( vektor < røye > :: const_iterator den = vtr. begynne ( ) ; den ! = vtr. slutt ( ) ; den ++ )

cout << * den << ' ' ;

cout << endl ;



komme tilbake 0 ;

}

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

Merk: clear() sletter alle elementene i vektoren. Faktisk øremerker den alle elementene som slettet, slik at andre koder kan ta opp minneplasseringene deres. Hvis minneplasseringen til et element ennå ikke er tatt opp av en annen kode, kan elementet fortsatt gjenbrukes på vegne av den samme vektoren.

Vektorsletting

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

en. viske ut ( q )

og

en. viske ut ( q1,q2 )

hvor a er navnet på vektoren.

iterator erase (const_iterator posisjon)

Dette er den fulle syntaksen for 'a.erase(q)'. Den returnerer en iterator som peker på elementet, som var like bak det som ble slettet. Argumentet q er en iterator som peker på elementet som skal slettes. Følgende program illustrerer dette:

#inkluder

#include

ved hjelp av navneområde std ;



int hoved- ( )

{

vektor < røye > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'I' } ;



vektor < røye > :: iterator iter = vtr. begynne ( ) ;

++ iter ; ++ iter ;



vektor < røye > :: iterator den = vtr. viske ut ( iter ) ;



til ( int Jeg = 0 ; Jeg < vtr. størrelse ( ) ; Jeg ++ ) {

cout << vtr [ Jeg ] << ' ' ;

}

cout << endl ;



cout << * den << endl ;



komme tilbake 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, begin(), 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.erase(iter)'.

Rekkevidde i vektor

For listen,

'P' , 'Q' , 'R' , 'S' , 'T' , 'I'

sekvensen 'Q', 'R', 'S', 'T' er et område. Men med C++-beholdere, det siste elementet, 'T' regnes ikke som en del av utvalget. Dette er indikert i generelle termer som:

[ jeg, j )

eller

[ q1, q2 )

'[' betyr i dette tilfellet 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 den fulle syntaksen for 'a.erase(q1,q2)'. Den returnerer en iterator som peker på elementet, som var like bak området som ble slettet. Merk: det siste elementet i området slettes ikke. Så den returnerte iteratoren vil peke til det siste elementet i området. Argumentene q1 og q2 er iteratorer som peker på de første og siste elementene i området. Følgende program illustrerer dette:

#inkluder

#include

ved hjelp av navneområde std ;



int hoved- ( )

{

vektor < røye > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'I' } ;



vektor < røye > :: iterator itB = vtr. begynne ( ) ;

++ itB ;

vektor < røye > :: iterator itE = vtr. slutt ( ) ;

-- itE ; -- itE ;



vektor < røye > :: iterator den = vtr. viske ut ( itB, itE ) ;



til ( int Jeg = 0 ; Jeg < vtr. størrelse ( ) ; Jeg ++ ) {

cout << vtr [ Jeg ] << ' ' ;

}

cout << endl ;



cout << * den << endl ;



komme tilbake 0 ;

}

Utgangen er:

P T U

T

'Q', 'R', 'S' er slettet. Den returnerte iteratoren peker nå til 'T', som var det siste elementet i beholderområdet. Medlemsfunksjonen, end(), returnerer en iterator som peker like etter det siste elementet i vektoren. I koden ble denne iteratoren redusert 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.erase(itB, itE)'.

const vektor og erase()

Hvis deklarasjonen av en vektor er innledet med const, for konstant, kan ingen av elementene slettes. Følgende program vil ikke kompilere, og gir en feilmelding for a.erase(q)-uttrykket:

#inkluder

#include

ved hjelp av navneområde std ;



int hoved- ( )

{

konst vektor < røye > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'I' } ;



vektor < røye > :: const_iterator iter = vtr. begynne ( ) ;

++ iter ; ++ iter ;



vektor < røye > :: const_iterator den = vtr. viske ut ( iter ) ;



til ( int Jeg = 0 ; Jeg < vtr. størrelse ( ) ; Jeg ++ ) {

cout << vtr [ Jeg ] << ' ' ;

}

cout << endl ;



cout << * den << endl ;



komme tilbake 0 ;

}

Hvis leseren prøvde programmet, ville han fått en feilmelding. Programmet ville ikke ha kompilert.

Følgende program vil ikke kompilere, og gir en feilmelding for uttrykket a.erase(q1,q2):

#inkluder

#include

ved hjelp av navneområde std ;



int hoved- ( )

{

konst vektor < røye > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'I' } ;



vektor < røye > :: const_iterator itB = vtr. begynne ( ) ;

++ itB ;

vektor < røye > :: const_iterator itE = vtr. slutt ( ) ;

-- itE ; -- itE ;



vektor < røye > :: const_iterator den = vtr. viske ut ( itB, itE ) ;



til ( int Jeg = 0 ; Jeg < vtr. størrelse ( ) ; Jeg ++ ) {

cout << vtr [ Jeg ] << ' ' ;

}

cout << endl ;



cout << * den << endl ;



komme tilbake 0 ;

}

Merk: erase() sletter et element eller en rekke elementer. Faktisk øremerker den et element som slettet, slik at minneplasseringene deres kan tas opp av andre koder. Hvis minneplasseringen til et element ennå ikke er tatt opp av en annen kode, kan elementet fortsatt gjenbrukes på vegne av den samme vektoren.

pop_back()

Pop_back() vektormedlemsfunksjonen er en slags slette() funksjon. Den sletter imidlertid bare det siste elementet i vektoren. Syntaksen er:

tomrom pop_back ( )

Det tar ingen argumenter og returnerer ugyldig. Følgende program illustrerer bruken:

#inkluder

#include

ved hjelp av navneområde std ;



int hoved- ( )

{

vektor < røye > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'I' } ;



vtr. pop_back ( ) ;



til ( int Jeg = 0 ; Jeg < vtr. størrelse ( ) ; Jeg ++ ) {

cout << vtr [ Jeg ] << ' ' ;

}

cout << endl ;



komme tilbake 0 ;

}

Utgangen er:

P Q R S T

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

Ødelegge en vektor

Kan en vektor ødelegges? – Ja! Men når en vektor blir ødelagt, slettes alle dens elementer bortsett fra navnet; betyr at vektordeklarasjonen fortsatt kan gjenbrukes, men med en viss usikkerhet. Syntaksen for å ødelegge en vektor er:

a.~X ( )

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

#inkluder

#include

ved hjelp av navneområde std ;



int hoved- ( )

{

vektor < røye > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'I' } ;



vtr.~vektor ( ) ;



vtr = { 'I' , 'I' , 'X' , 'OG' , 'MED' } ;



til ( int Jeg = 0 ; Jeg < vtr. størrelse ( ) ; Jeg ++ ) {

cout << vtr [ Jeg ] << ' ' ;

}

cout << endl ;



vtr.~vektor ( ) ;



vtr. push_back ( 'EN' ) ;

vtr. push_back ( 'B' ) ;

vtr. push_back ( 'C' ) ;

vtr. push_back ( 'D' ) ;

vtr. push_back ( 'OG' ) ;



til ( int Jeg = 0 ; Jeg < vtr. størrelse ( ) ; Jeg ++ ) {

cout << vtr [ Jeg ] << ' ' ;

}

cout << endl ;

komme tilbake 0 ;

}

Utgangen er:

V W X Y Z
s ^ t e @ A  C D E

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

Konklusjon

Vektormedlemsfunksjonen clear() kan sammenlignes med vektormedlemsfunksjonen erase(). De er ikke erstatninger. clear() sletter alle elementene i vektoren. Faktisk øremerker den alle elementene som slettet, slik at deres minneplasseringer kan tas opp av andre koder. Hvis minneplasseringen til et element ennå ikke er tatt opp av en annen kode, kan elementet fortsatt gjenbrukes på vegne av den samme vektoren. erase() sletter et element eller en rekke elementer. Faktisk øremerker den et element som slettet, slik at minneplasseringen kan tas opp av en annen kode. Hvis minneplasseringen til et element som er slettet ennå ikke er tatt opp av en annen kode, kan elementet fortsatt gjenbrukes på vegne av den samme vektoren. klar har likhet med ødelegge, ~X().