C++ vektoril on palju liikmefunktsioone. Kaks neist on tühjenda () ja kustuta (). selge () 'eemaldab' kõik vektori elemendid. erase() 'eemaldab' ühe elemendi või elementide vahemiku. Vektori liikmefunktsioonil erase() on kaks ülekoormatud varianti.
Selle artikli pealkiri on tegelikult 'Vector clear() Member Function versus Vector erase() Member Function, C++ keeles'. See on kaheliikmeliste funktsioonide võrdlus. See käsitleb seda, millal mida kasutada, kuidas ja millistel tingimustel kumbagi kasutatakse.
Vektori kasutamiseks C++ programmis peaks programm algama järgmisega:
#include
#include
kasutades nimeruum std ;
Artikli sisu
Vektor selge()
Clear() liige funktsioon 'eemaldab' kõik vektori elemendid. Selle süntaks on:
tühine selge ( )
See naaseb tühjaks. Järgmine programm illustreerib selle kasutamist väljendiga 'vtr.clear();':
#include
#include
kasutades nimeruum std ;
int peamine ( )
{
vektor < char > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'IN' } ;
jaoks ( vektor < char > :: iteraator seda = vtr. alustada ( ) ; seda ! = vtr. lõpp ( ) ; seda ++ )
cout << * seda << '' ;
cout << endl ;
vtr. selge ( ) ;
jaoks ( vektor < char > :: iteraator seda = vtr. alustada ( ) ; seda ! = vtr. lõpp ( ) ; seda ++ )
cout << * seda << '' ;
cout << endl ;
tagasi 0 ;
}
Väljund on üks rida:
P Q R S T UKui vektorit poleks tühjendatud, oleks väljundiks olnud kaks sama jada rida. Teist rida ei kuvata, kuna kõik elemendid kustutati.
const vektor ja clear()
Kui vektori deklaratsioonile eelneb konst, tähendab see, et vektori elemente ei saa kustutada ega muuta. Kui avaldis üritab mõnda elementi muuta või kustutada, siis programm ei kompileeri. Testige järgmist programmi ja pange tähele, et see ei kompileeri:
#include#include
kasutades nimeruum std ;
int peamine ( )
{
konst vektor < char > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'IN' } ;
jaoks ( vektor < char > :: const_iterator seda = vtr. alustada ( ) ; seda ! = vtr. lõpp ( ) ; seda ++ )
cout << * seda << '' ;
cout << endl ;
vtr. selge ( ) ;
jaoks ( vektor < char > :: const_iterator seda = vtr. alustada ( ) ; seda ! = vtr. lõpp ( ) ; seda ++ )
cout << * seda << '' ;
cout << endl ;
tagasi 0 ;
}
Kui programmi oleks testitud, oleks välja antud veateade ja kompileerimist poleks olnud. Kuna vektor kuulutati konstantseks, ei saanud funktsioon clear() töötada, mille tulemuseks oli kompilaatori veateade.
Märge: clear() kustutab kõik vektori elemendid. Tegelikult märgib see kõik elemendid kustutatuks, nii et teised koodid võivad hõivata nende mälukohad. Kui mõne elemendi mälukohta pole veel mõni teine kood hõivanud, saab elementi sama vektori nimel siiski uuesti kasutada.
Vektori kustutamine
Kahe erase() liikmefunktsiooni lihtsustatud süntaksid on järgmised:
a. kustutada ( q )ja
a. kustutada ( q1, q2 )
kus a on vektori nimi.
iteraatori kustutamine (const_iterator position)
See on 'a.erase(q)' täielik süntaks. See tagastab iteraatori, mis osutab elemendile, mis oli kohe kustutatud elemendi taga. Argument q on iteraator, mis osutab kustutatavale elemendile. Seda illustreerib järgmine programm:
#include#include
kasutades nimeruum std ;
int peamine ( )
{
vektor < char > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'IN' } ;
vektor < char > :: iteraator iter = vtr. alustada ( ) ;
++ iter ; ++ iter ;
vektor < char > :: iteraator seda = vtr. kustutada ( iter ) ;
jaoks ( int i = 0 ; i < vtr. suurus ( ) ; i ++ ) {
cout << vtr [ i ] << '' ;
}
cout << endl ;
cout << * seda << endl ;
tagasi 0 ;
}
Väljund on:
P Q S T US
'R' on kustutatud. Tagastatud iteraator osutab nüüd 'S'-le, mis oli vahetult pärast 'R'. Liikfunktsioon begin() tagastab iteraatori, mis osutab vektori esimesele elemendile. Koodis suurendati seda iteraatorit kaks korda, et osutada 'R'-le. 'R' kustutati väljendiga 'vtr.erase(iter)'.
Vahemik vektoris
Nimekirja jaoks
'P' , 'Q' , 'R' , 'S' , 'T' , 'IN'jada 'Q', 'R', 'S', 'T' on vahemik. C++ konteinerite puhul ei peeta viimast elementi 'T' aga vahemiku osaks. Seda näidatakse üldiselt järgmiselt:
[ i, j )või
[ q1, q2 )
'[' tähendab antud juhul, et jada esimene element on kaasatud, ja ')' tähendab, et viimast elementi ei kaasata.
iterator erase(const_iterator esimene, const_iterator viimane)
See on 'a.erase(q1,q2)' täielik süntaks. See tagastab iteraatori, mis osutab elemendile, mis oli kohe kustutatud vahemiku taga. Märkus: vahemiku viimast elementi ei kustutata. Seega osutab tagastatud iteraator vahemiku viimasele elemendile. Argumendid q1 ja q2 on iteraatorid, mis osutavad vahemiku esimesele ja viimasele elemendile. Seda illustreerib järgmine programm:
#include#include
kasutades nimeruum std ;
int peamine ( )
{
vektor < char > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'IN' } ;
vektor < char > :: iteraator seeB = vtr. alustada ( ) ;
++ seeB ;
vektor < char > :: iteraator itE = vtr. lõpp ( ) ;
-- itE ; -- itE ;
vektor < char > :: iteraator seda = vtr. kustutada ( itB, itE ) ;
jaoks ( int i = 0 ; i < vtr. suurus ( ) ; i ++ ) {
cout << vtr [ i ] << '' ;
}
cout << endl ;
cout << * seda << endl ;
tagasi 0 ;
}
Väljund on:
P T UT
'Q', 'R', 'S' on välja jäetud. Tagastatud iteraator osutab nüüd T-le, mis oli konteinerivahemiku viimane element. Liikfunktsioon end() tagastab iteraatori, mis osutab vahetult pärast vektori viimast elementi. Koodis vähendati seda iteraatorit kaks korda, et osutada vahemiku viimasele elemendile T. 'Q', 'R', 'S' kustutati ilma viimase elemendita 'T' vahemikus 'vtr.erase(itB, itE)'.
const vektor ja erase ()
Kui vektori deklaratsiooni ees on konstanti jaoks konst, siis ei saa ühtegi selle elementi kustutada. Järgmine programm ei kompileeri, väljastades a.erase(q) avaldise jaoks veateate:
#include#include
kasutades nimeruum std ;
int peamine ( )
{
konst vektor < char > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'IN' } ;
vektor < char > :: const_iterator iter = vtr. alustada ( ) ;
++ iter ; ++ iter ;
vektor < char > :: const_iterator seda = vtr. kustutada ( iter ) ;
jaoks ( int i = 0 ; i < vtr. suurus ( ) ; i ++ ) {
cout << vtr [ i ] << '' ;
}
cout << endl ;
cout << * seda << endl ;
tagasi 0 ;
}
Kui lugeja programmi prooviks, oleks ta saanud veateate. Programmi poleks koostatud.
Järgmine programm ei kompileeri, väljastades a.erase(q1,q2) avaldise jaoks veateate:
#include#include
kasutades nimeruum std ;
int peamine ( )
{
konst vektor < char > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'IN' } ;
vektor < char > :: const_iterator seeB = vtr. alustada ( ) ;
++ seeB ;
vektor < char > :: const_iterator itE = vtr. lõpp ( ) ;
-- itE ; -- itE ;
vektor < char > :: const_iterator seda = vtr. kustutada ( itB, itE ) ;
jaoks ( int i = 0 ; i < vtr. suurus ( ) ; i ++ ) {
cout << vtr [ i ] << '' ;
}
cout << endl ;
cout << * seda << endl ;
tagasi 0 ;
}
Märkus. Erase() kustutab elemendi või elementide vahemiku. Tegelikult märgib see elemendi kustutatuks, nii et nende mälukohad saavad hõivata muud koodid. Kui mõne elemendi mälukohta pole veel mõni teine kood hõivanud, saab elementi sama vektori nimel siiski uuesti kasutada.
pop_back()
Pop_back() vektorliikme funktsioon on omamoodi erase() funktsioon. Kuid see kustutab ainult vektori viimase elemendi. Süntaks on:
tühine pop_back ( )See ei nõua argumente ja tagastab tühisuse. Järgmine programm illustreerib selle kasutamist:
#include#include
kasutades nimeruum std ;
int peamine ( )
{
vektor < char > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'IN' } ;
vtr. pop_back ( ) ;
jaoks ( int i = 0 ; i < vtr. suurus ( ) ; i ++ ) {
cout << vtr [ i ] << '' ;
}
cout << endl ;
tagasi 0 ;
}
Väljund on:
P Q R S TViimane element 'U' on eemaldatud (kustutatud).
Vektori hävitamine
Kas vektorit saab hävitada? — Jah! Kui aga vektor hävitatakse, kustutatakse kõik selle elemendid peale selle nime; See tähendab, et vektori deklaratsiooni saab siiski uuesti kasutada, kuid teatud ebakindlusega. Vektori hävitamise süntaks on:
a.~X ( )kus 'a' on vektori nimi. Seda illustreerib järgmine programm:
#include#include
kasutades nimeruum std ;
int peamine ( )
{
vektor < char > vtr = { 'P' , 'Q' , 'R' , 'S' , 'T' , 'IN' } ;
vtr.~vektor ( ) ;
vtr = { 'IN' , 'IN' , 'X' , 'JA' , 'WITH' } ;
jaoks ( int i = 0 ; i < vtr. suurus ( ) ; i ++ ) {
cout << vtr [ i ] << '' ;
}
cout << endl ;
vtr.~vektor ( ) ;
vtr. lükka tagasi ( 'A' ) ;
vtr. lükka tagasi ( 'B' ) ;
vtr. lükka tagasi ( 'C' ) ;
vtr. lükka tagasi ( 'D' ) ;
vtr. lükka tagasi ( 'JA' ) ;
jaoks ( int i = 0 ; i < vtr. suurus ( ) ; i ++ ) {
cout << vtr [ i ] << '' ;
}
cout << endl ;
tagasi 0 ;
}
Väljund on:
V K X Y Zlk ^ t e @ A C D E
autori arvutist koos mõne ebausaldusväärse tegelasega teise rea jaoks.
Järeldus
Vektorliikme funktsiooni clear() saab võrrelda vektoriliikme funktsiooniga erase(). Need ei ole asendajad. Clear() kustutab kõik vektori elemendid. Tegelikult märgib see kõik elemendid kustutatuks, nii et nende mälukohad saavad hõivata muud koodid. Kui mõne elemendi mälukohta pole veel mõni teine kood hõivanud, saab elementi sama vektori nimel siiski uuesti kasutada. erase() kustutab elemendi või elementide vahemiku. Tegelikult märgib see elemendi kustutatuks, nii et mälukoha saab hõivata muu koodiga. Kui mõne kustutatud elemendi mälukohta pole veel mõni teine kood hõivanud, saab elementi sama vektori nimel uuesti kasutada. selgel on sarnasus hävitamiseks, ~X().