C ++ Vektor klar gegen Löschen

Der C ++ - Vektor hat viele Mitgliederfunktionen. Zwei von ihnen sind Clear () und erase (). klar() "Entfernt" alle Elemente des Vektors. Erase () „entfernt“ ein einzelnes Element oder eine Reihe von Elementen. Für den Vektor gibt es zwei überlastete Varianten der Member -Funktion von erase ().

Der Titel dieses Artikels lautet tatsächlich "Vector Clear () Mitgliedsfunktion gegenüber Vektor erase () Mitgliedsfunktion in C ++". Dies ist ein Vergleich der Zwei-Mitglieder-Funktionen. Es handelt.

Um einen Vektor in einem C ++ - Programm zu verwenden, sollte das Programm mit:

#enthalten
#enthalten
Verwenden von Namespace STD;

Artikelinhalt

• Vektor klar ()
• Vektorlösche
• Pop zurück
• Einen Vektor zerstören
• Abschluss

Vektor klar ()

Die Clear () -Mitglied -Funktion "entfernt" alle Elemente des Vektors. Seine Syntax ist:

void clear ()

Es kehrt ungültig zurück. Das folgende Programm veranschaulicht seine Verwendung mit dem Ausdruck „VTR.klar();":

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Vektor vtr = 'p', 'q', 'r', 's', 't', 'u';
für (Vektor:: iterator it = vtr.Start(); Es != vtr.Ende(); es ++)
Cout << *it << ";
Cout << endl;
vtr.klar();
für (Vektor:: iterator it = vtr.Start(); Es != vtr.Ende(); es ++)
Cout << *it << ";
Cout << endl;
Rückkehr 0;

Die Ausgabe ist die einzige Zeile:

P q r s t u

Wenn der Vektor nicht gelöscht worden wäre, wäre der Ausgang zwei Zeilen derselben Sequenz gewesen. Es wurde keine zweite Zeile angezeigt, da alle Elemente gelöscht wurden.

const vector und clear ()

Wenn eine Vektorerklärung von const vorangestellt wird, bedeutet dies, dass die Elemente des Vektors nicht gelöscht oder geändert werden können. Wenn ein Ausdruck versucht, die Elemente zu ändern oder zu löschen, wird das Programm nicht kompiliert. Testen Sie das folgende Programm und beachten Sie, dass es nicht kompiliert wird:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Const Vector vtr = 'p', 'q', 'r', 's', 't', 'u';
für (Vektor:: const_iterator it = vtr.Start(); Es != vtr.Ende(); es ++)
Cout << *it << ";
Cout << endl;
vtr.klar();
für (Vektor:: const_iterator it = vtr.Start(); Es != vtr.Ende(); es ++)
Cout << *it << ";
Cout << endl;
Rückkehr 0;

Wenn das Programm getestet worden wäre, wäre eine Fehlermeldung ausgegeben worden, und es hätte keine Zusammenstellung gegeben. Da der Vektor konstant erklärt wurde, konnte die Funktion clear () nicht funktionieren, was zu einer Fehlermeldung des Compilers führte.

Notiz: Clear () löscht alle Elemente des Vektors. Tatsächlich ist es so, dass alle Elemente gelöscht werden, sodass andere Codes ihre Speicherorte in Anspruch nehmen können. Wenn der Speicherort eines Elements noch nicht von einem anderen Code übernommen wurde, kann das Element im Namen desselben Vektors immer noch wiederverwendet werden.

Vektorlösche

Die vereinfachten Syntaxen für die beiden ERASE () -Mitglied -Funktionen sind:

A.löschen (q)
Und
A.löschen (Q1, Q2)

wobei a der Name des Vektors ist.

Iterator -Löschen (const_iteratorposition)

Dies ist die vollständige Syntax für „a.löschen (q) ”. Es gibt einen Iterator zurück, der auf das Element zeigt, das direkt hinter dem gelöscht wurde. Das Argument, Q ist ein Iterator, der auf das zu gelöschte Element zeigt. Das folgende Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Vektor vtr = 'p', 'q', 'r', 's', 't', 'u';
Vektor:: iterator iter = vtr.Start();
++Iter; ++ iter;
Vektor:: iterator it = vtr.löschen (iter);
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";

Cout << endl;
Cout << *it << endl;
Rückkehr 0;

Die Ausgabe ist:

P q s t u
S

'R' wurde gelöscht. Der zurückgegebene Iterator verweist nun auf 's', der kurz nach 'R' war. Die Mitgliedsfunktion begin () gibt einen Iterator zurück, der auf das erste Element des Vektors verweist. Im Code wurde dieser Iterator zweimal inkrementiert, um auf 'R' zu verweisen. 'R' wurde mit dem Ausdruck gelöscht, „VTR.löschen (iter) ”.

Bereich im Vektor

Für die Liste,

'P', 'Q', 'R', 'S', 'T', 'u'

Die Sequenz, 'q', 'r', 's', 't' ist eine Reichweite. Bei C ++ - Containern wird das letzte Element 'T' jedoch nicht als Teil des Bereichs angesehen. Dies ist allgemein angegeben wie:

[i, j)
oder
[Q1, Q2)

'[' bedeutet in diesem Fall, dass das erste Element in der Sequenz enthalten ist und ') bedeutet, dass das letzte Element nicht enthalten ist.

Iterator -Löschen (const_iterator zuerst, const_iterator zuletzt)

Dies ist die vollständige Syntax für „a.Röte (Q1, Q2) ”. Es gibt einen Iterator zurück, der auf das Element zeigt, das direkt hinter dem Löschbereich lag. Hinweis: Das letzte Element im Bereich wird nicht gelöscht. Der zurückgegebene Iterator verweist also auf das letzte Element des Bereichs. Die Argumente Q1 und Q2 sind Iteratoren, die auf die ersten und letzten Elemente des Bereichs zeigen. Das folgende Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Vektor vtr = 'p', 'q', 'r', 's', 't', 'u';
Vektor:: iterator itb = vtr.Start();
++ITB;
Vektor:: iterator ite = vtr.Ende();
--ite; --ite;
Vektor:: iterator it = vtr.löschen (ITB, ITE);
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";

Cout << endl;
Cout << *it << endl;
Rückkehr 0;

Die Ausgabe ist:

P t u
T

'Q', 'r', 'S' wurden gelöscht. Der zurückgegebene Iterator verweist nun auf 'T', das das letzte Element im Containerbereich war. Die Mitgliedsfunktion End () gibt einen Iterator zurück, der kurz nach dem letzten Element des Vektors zeigt. Im Code wurde dieser Iterator zweimal abgeschlossen, um auf 'T', dem letzten Element des Bereichs. 'Q', 'r', 's' wurden ohne das letzte Element 't' im Bereich mit dem Ausdruck „VTR.löschen (ITB, ITE) ”.

const vector und erase ()

Wenn der Erklärung eines Vektors konstant konstant vorgeht, kann keiner seiner Elemente gelöscht werden. Das folgende Programm wird nicht kompiliert und eine Fehlermeldung für das a veröffentlicht.Ausdruck von Löschen (q):

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Const Vector vtr = 'p', 'q', 'r', 's', 't', 'u';
Vektor:: const_iterator iter = vtr.Start();
++Iter; ++ iter;
Vektor:: const_iterator it = vtr.löschen (iter);
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";

Cout << endl;
Cout << *it << endl;
Rückkehr 0;

Wenn der Leser das Programm ausprobiert hätte, hätte er eine Fehlermeldung erhalten. Das Programm hätte nicht zusammengestellt.

Das folgende Programm wird nicht kompiliert und eine Fehlermeldung für das a veröffentlicht.Ausdruck von Röten (Q1, Q2):

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Const Vector vtr = 'p', 'q', 'r', 's', 't', 'u';
Vektor:: const_iterator itb = vtr.Start();
++ITB;
Vektor:: const_iterator ite = vtr.Ende();
--ite; --ite;
Vektor:: const_iterator it = vtr.löschen (ITB, ITE);
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";

Cout << endl;
Cout << *it << endl;
Rückkehr 0;

Hinweis: Erase () löscht ein Element oder eine Reihe von Elementen. Tatsächlich ist es ein wie gelöschter Element, so dass ihre Speicherorte von anderen Codes übernommen werden können. Wenn der Speicherort eines Elements noch nicht von einem anderen Code übernommen wurde, kann das Element im Namen desselben Vektors immer noch wiederverwendet werden.

Pop zurück()

Die Funktion pop_back () Vektorelement ist eine Art ERASE () -Funktion. Es löscht jedoch nur das letzte Element des Vektors. Die Syntax ist:

void pop_back ()

Es erfordert kein Argument und gibt Leere zurück. Das folgende Programm zeigt die Verwendung:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Vektor vtr = 'p', 'q', 'r', 's', 't', 'u';
vtr.Pop zurück();
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";

Cout << endl;
Rückkehr 0;

Die Ausgabe ist:

P q r s t

Das letzte Element, 'u' wurde entfernt (gelöscht).

Einen Vektor zerstören

Kann ein Vektor zerstört werden?? - Ja! Wenn jedoch ein Vektor zerstört wird, werden alle seine Elemente außer seinem Namen gelöscht; Dies bedeutet. Die Syntax, um einen Vektor zu zerstören, lautet:

A.~ X ()

wo 'a' der Name des Vektors ist. Das folgende Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Vektor vtr = 'p', 'q', 'r', 's', 't', 'u';
vtr.~ vector ();
vtr = 'v', 'w', 'x', 'y', 'z';
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";

Cout << endl;
vtr.~ vector ();
vtr.push_back ('a');
vtr.push_back ('b');
vtr.push_back ('c');
vtr.push_back ('d');
vtr.push_back ('e');
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";

Cout << endl;
Rückkehr 0;

Die Ausgabe ist:

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

vom Computer des Autors mit einigen unzuverlässigen Zeichen für die zweite Zeile.

Abschluss

Die Vektorelementfunktion Clear () kann mit der Vektorelementfunktion ERASE () verglichen werden. Sie sind keine Ersatzstoffe. Clear () löscht alle Elemente des Vektors. Eigentlich ist es alle so gelöschten Elemente, so dass ihre Speicherorte von anderen Codes übernommen werden können. Wenn der Speicherort eines Elements noch nicht von einem anderen Code übernommen wurde, kann das Element im Namen desselben Vektors immer noch wiederverwendet werden. erase () löscht ein Element oder eine Reihe von Elementen. Tatsächlich ist es ein gelöschtes Element, so dass der Speicherort von einem anderen Code übernommen werden kann. Wenn der Speicherort eines gelöschten Elements noch nicht von einem anderen Code übernommen wurde, kann das Element immer noch im Namen desselben Vektors wiederverwendet werden. Klar hat Ähnlichkeit zu Zerstören, ~ x ().