Wie entferne ich ein bestimmtes Element von einem Vektor in C++?

Der C ++ - Vektor hat viele Mitgliederfunktionen. Zwei dieser Mitgliedsfunktionen sind erase () und pop_back (). pop_back () entfernt das letzte Element aus dem Vektor. Um alle Elemente aus dem Vektor mit pop_back () zu entfernen, muss die Funktion pop_back () wiederholt werden, wie oft Elemente sind. Die Funktion erase () kann ein Element von Anfang an, innerhalb oder am Ende des Vektors entfernen. Um alle Elemente aus dem Vektor zu entfernen, muss die Funktion erase () mit erase () wiederholt werden, wie oft Elemente ab dem ersten Element abhauen.

Um ein bestimmtes Element aus dem C ++ - Vektor zu entfernen, muss das Element identifiziert werden. In Bezug auf die Funktion von ERase () wird das Element von einem Iterator identifiziert. Die nächste Frage ist: „Was ist ein Iterator?" - siehe unten. Da die Funktion pop_back () das letzte Element per Definition entfernt wird, wurde das spezifische Element, das es entfernen muss, bereits indirekt identifiziert.

Um die Vektorbibliothek in C ++ zu verwenden, muss das Programm mit:

#enthalten
#enthalten
Verwenden von Namespace STD;

In diesem Artikel wird erklärt++. Der gesamte Vektorcode für diesen Artikel befindet sich in der Haupt- () Funktionsbehörde.

Artikelinhalt

• Einführung - siehe oben
• Identifizieren von Vektorelementen
• Entfernen mit ERASE ()
• Entfernen mit pop_back
• Abschluss

Identifizieren von Vektorelementen

Identifizierung durch Referenz
Betrachten Sie den folgenden Vektor:

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

VTR [0] gibt 'a' zurück. VTR [1] gibt 'B' zurück. VTR [2] gibt 'C' zurück. VTR [3] gibt 'D' zurück. VTR [4] gibt 'e' zurück. Dies identifiziert sich durch Referenz. Die Zahl in quadratischen Klammern wird als Index bezeichnet. Es kann in einem für die Schleife erfolgen, wie das folgende Programm zeigt:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
für (int i = 0; iCout << vtr[i] << ";
Cout << endl;
Rückkehr 0;

Die Ausgabe ist:

A b c d e

Identifizierung durch Iterator
Betrachten Sie den folgenden Vektor:

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

it = vtr.begin () bedeutet, dass 'es' ein Iterator ist, der auf 'a' hinweist .

Es weist ++ auf 'B' verweist.

Es weist ++ auf 'C' zu, inkrementiert, nachdem es auf 'B' hinweist.

Es weist ++ auf 'D' zu, inkrementiert, nachdem es auf 'C' hinweist.

Es weist ++ auf 'e' zu, inkrementiert, nachdem es auf 'D' hinweist.

Es weist ++ auf VTR auf.End (), das über das letzte Element hinausgeht, und nach dem Hinweis auf 'E' inkrementiert.

Dies kann in einer Fürsovergabe erfolgen, wie das folgende Programm zeigt:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
für (vector :: iterator it = vtr.Start(); Es != vtr.Ende(); es ++)
Cout << *it << ";
Cout << endl;
Rückkehr 0;

Die Ausgabe ist:

A b c d e

Der erste Iterator wurde mit der Erklärung erhalten:

Vektor :: Iterator es

wo 'es' der Kenner des Iterators ist.

Sich immer noch auf denselben Vektor beziehen,

it = vtr.Ende () zeigt direkt über das letzte Element 'e' .

It- zeigt auf 'e'.

IT-.

IT-.

IT-.

Es zeigt auf 'A', abgeschlossen, nachdem es auf 'B' hinweist.

Dieses Schema kann verwendet werden, um den Vektor in umgekehrter Reihenfolge anzuzeigen, wie das folgende Programm zeigt:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
Vektor :: Iterator it = vtr.Ende();
für (it = -it; it> = vtr.Start(); Es--)
Cout << *it << ";
Cout << endl;
Rückkehr 0;

Die Ausgabe ist:

E d c b a

Der anfängliche Iterator für die For-Schleife ist abgeschlossen. ich.e. "Es = -it;". Beachten Sie die Bedingung für die For-Schleife, ich.e. „Es> = vtr.Start();".

Um den von dem Iterator gerichteten Wert zu erhalten, muss der Iterator vom Indirektionoperator * Derferenziert werden, *.

Entfernen mit ERASE ()

Die Syntax, um ein Element aus einem Vektor zu löschen (zu entfernen), lautet:

A.löschen (q)

wobei 'a' der Name des Vektors ist und Q ein Iterator ist, der auf das Element zeigt, das entfernt werden soll. Das heißt, Q identifiziert das spezifische Element, das entfernt werden soll. Die Mitgliedsfunktion gibt einen Iterator zurück, der kurz nach dem Entfernen des Elements auf das Element verweist.

Entfernen von vorne
Die Funktionserleitungsfunktion kann ein Element von der Vorderseite des Vektors entfernen. Das folgende Programm zeigt dies:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
Vektor :: Iterator q = vtr.Start();
Vektor :: Iterator p = vtr.löschen (q);
Cout << *p << endl;
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";
Cout << endl;
für (vector :: iterator it = vtr.Start(); Es != vtr.Ende(); es ++)
Cout << *it << ";
Cout << endl;
Rückkehr 0;

Die Ausgabe ist:

B
B c d e
B c d e

Die ersten beiden Zeilen im Programm umfassen Anweisungen, einschließlich der erforderlichen Bibliotheken. Die nächste Zeile erklärt, dass jeder verwendete Name aus dem Standard -Namespace stammt, sofern nicht anders angegeben.

In der Funktion main () deklariert die erste Anweisung den Vektor. Die Aussage nach der Rückgabe eines Iterators Q, der auf das erste Element des Vektors verweist. Die folgende Aussage ist die Interessenserklärung. Es entfernt das erste Element, auf das q verweist. Es gibt einen Iterator zurück, der auf das Element verweist, das kurz nach dem Entfernen des Elements war. Die Anweisung nach dem Druck des Wertes des Elements, auf das der Iterator nach dem Entfernen zeigt. In den nächsten beiden Codesegmenten werden die verbleibenden Werte im Vektor angezeigt. Die erste dieser Codesegmente verwendet Referenzen. Der zweite verwendet Iteratoren.

Entfernen von innen
Um das Wertelement "C" zu entfernen, muss der Iterator durch begin () zurückgegeben werden, um auf das Wertelement "C" zu zeigen, um auf das Wertelement zu verweisen. Mit der Member -Funktion von erase () kann dann das Iterator das Element entfernen. Das folgende Programm zeigt dies:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
Vektor :: Iterator q = vtr.Start();
Q ++; Q ++;
Vektor :: Iterator p = vtr.löschen (q);
Cout << *p << endl;
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";
Cout << endl;
für (vector :: iterator it = vtr.Start(); Es != vtr.Ende(); es ++)
Cout << *it << ";
Cout << endl;
Rückkehr 0;

Die Ausgabe ist:

D
A b d e
A b d e

Entfernen Sie von hinten mit erase ()
Um das Wertelement "E" zu entfernen, muss der Iterator bis zum Ende () einmal dekrementiert werden, um auf das Wertelement "E" zu verweisen. Mit der Member -Funktion von erase () kann dann das Iterator das Element entfernen. Das folgende Programm zeigt dies:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
Vektor :: Iterator q = vtr.Ende();
Q--;
Vektor :: Iterator p = vtr.löschen (q);
Cout << *p << endl;
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";
Cout << endl;
für (vector :: iterator it = vtr.Start(); Es != vtr.Ende(); es ++)
Cout << *it << ";
Cout << endl;
Rückkehr 0;

Die Ausgabe ist:

E
A B C D
A B C D

Hier gibt es eine Nuance. Der Iterator kehrte von End () auf das Element zurück, das hätte dort sein sollen, wenn es nicht entfernt worden wäre.

Entfernen mit pop_back

Die Funktion pop_back () wird per Definition das letzte Element des Vektors entfernt. Daher muss der Programmierer das letzte Element nicht identifizieren. Seine Syntax ist

A.Pop zurück()

wo 'a' der Name des Vektors ist. Es braucht kein Argument; Es kehrt ungültig zurück. Das folgende Programm beseitigt das letzte Element eines Vektors:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
vtr.Pop zurück();
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";
Cout << endl;
für (vector :: iterator it = vtr.Start(); Es != vtr.Ende(); es ++)
Cout << *it << ";
Cout << endl;
Rückkehr 0;

Die Ausgabe ist:

A B C D
A B C D

Abschluss

Der C ++ - Vektor hat viele Mitgliederfunktionen. Zwei dieser Mitgliedsfunktionen sind erase () und pop_back (). pop_back () entfernt das letzte Element aus dem Vektor. Um alle Elemente aus dem Vektor mit pop_back () zu entfernen, muss die Funktion pop_back () wiederholt werden, wie oft Elemente sind. Die Funktion erase () kann ein Element von Anfang an, innerhalb oder am Ende des Vektors entfernen. Um alle Elemente aus dem Vektor zu entfernen, muss die Funktion erase () mit erase () wiederholt werden, wie oft Elemente ab dem ersten Element abhauen.

Um ein bestimmtes Element aus dem C ++ - Vektor zu entfernen, muss das Element identifiziert werden. Für die Funktion Erase () wird das Element von einem Iterator identifiziert. Da die Funktion pop_back () das letzte Element per Definition entfernt wird, wurde das spezifische Element, das es entfernen muss, bereits indirekt identifiziert.