Wie man einen Vektor in C ++ umgeht

Wenn ein Vektor Elemente in der Sequenz hat, 'a', 'b', 'c', 'd', 'e' und es wird so konfiguriert, dass seine Sequenz, 'e', 'D', ', wird C ',' B ',' A ' Dann wurde der Vektor umgekehrt. Leider ist eine solche direkte Reversibilität in C nicht möglich++. Ein Vektor in C ++ kann jedoch von hinten iteriert werden, und das ist die indirekte Reversibilität. Damit besteht nicht nötig, den Vektor wörtlich umzukehren. In diesem Artikel wird erläutert, wie Sie einen Vektor in C ++ von hinten iterieren und seine Elemente ändern können.

Vor der Verwendung eines Vektors in C ++ sollte das Programm mit beginnen,

#enthalten
#enthalten
Verwenden von Namespace STD;

mit der Vektorbibliothek enthalten. Es ist einfacher, die reverse Iteration nach einer Zusammenfassung der Weiterleitungs -Iteration zu verstehen. Die Forward -Iteration wird also zuerst zusammengefasst, bevor die umgekehrte Iteration erklärt wird.

Artikelinhalt

• Vorwärts -Iteration
• Reverse Iteration
• Konstante umgekehrte Iterator
• Abschluss

Vorwärts -Iteration

Vorwärts -Iteration befasst sich mit zwei Iteratoren. Ein Iterator ist ein ausgeführtes Zeigerobjekt mit besonderen Eigenschaften. Hier werden die beiden Interessens -Iteratoren von der Member -Funktion von begin () und der ende () Mitgliedsfunktion zurückgegeben. Die Funktion "start ()) gibt einen Iterator zurück, der auf das erste Element des Vektors verweist. Die Funktion End () Member gibt einen Iterator zurück, der direkt über das letzte Element des Vektors hinausgeht.

Angenommen, der Name des Vektors ist VTR, dann gibt die folgende Erklärung einen Iterator mit Beginn zurück:

Vektor:: iterator p = vtr.Start();

wobei P der Name des Iterators des Beginns ist. Die folgende Erklärung gibt einen End -Iterator zurück:

Vektor:: iterator q = vtr.Ende();

Wenn Q der Name des End -Iterators ist, ist er aus den beiden oben genannten Aussagen ersichtlich, dass p und q vom gleichen Typ sind und sogar austauscht werden können.

Alle Codesegmente für diesen Artikel sind in der Funktion main () geschrieben. Der folgende Code liest alle Elemente des Vektors vom Anfang bis zum letzten Element:

Vektor vtr = 'a', 'b', 'c', 'd', 'e';
für (Vektor:: iterator p = vtr.Start(); P != vtr.Ende(); p ++)
Cout << *p << ";

Cout < vtr = 'A', 'B', 'C', 'D', 'E';
Vektor:: iterator q = vtr.Ende();
für (q = --q; q> = vtr.Start(); Q--)
Cout << *q << ";

Cout << endl;

Die Ausgabe ist:

A b c d e

Der Code in den Klammern der For-Loop-Erklärung benötigt Erklärung. P ist ein Iterator, der zum ersten Mal auf das erste Element des Vektors zeigt. Obwohl es noch nicht über den Vektor hinaus zeigt, wird es durch P ++ erhöht, um auf jedes Element im Vektor zu verweisen. Wenn es auf ein Element im Vektor zeigt, wird der Wert (Zeichen) des Elements mit *p im Körper des For-Loop erhalten. * Ist der Indirektionoperator.

Der folgende Code liest und zeigt die Werte im Vektor vom letzten Element zum ersten Element mit dem End -Iterator an:

Vektorvtr = 'a', 'b', 'c', 'd', 'e';
Vektor:: iterator q = vtr.Ende();
für (q = --q; q> = vtr.Start(); Q--)
Cout << *q << ";

Cout << endl;

Die Ausgabe ist:

E d c b a

Der End -Iterator zeigt direkt über das Ende des Vektors, und das ist kein Element. Es muss also zunächst verringert werden, bevor es auf das letzte Element hinweisen kann. Von dort aus kann die Iteration rückwärts gehen.

Die Bedingung für die For-Schleife hier lautet: „Wenn Q größer oder gleich dem Iterator mit Beginn ist“. Es kann nicht sein, dass q nicht gleich dem Iterator mit Beginn ist ", da dies das erste Element ausschließen würde.

Dies ist eine informelle Art, rückwärts zu iterieren. Das heißt, dies ist eine informelle Möglichkeit, einen Vektor indirekt umzukehren.

Wert eines Elements ändern

Wenn die Instanziierung des Vektors nicht von Const (für Konstante) vorausgeht, kann der Wert eines Elements im Vektor geändert werden. Der folgende Code zeigt dies:

Vektor vtr = 'a', 'b', 'c', 'd', 'e';
Vektor:: iterator q = vtr.Ende();
Q--; Q--; Q--;
*q = 'z';
Vektor:: Iterator r = vtr.Ende();
für (r = - -r; r> = vtr.Start(); R--)
Cout << *r << ";

Cout << endl;

Die Ausgabe ist:

E d z b a

Der End-Iterator, Q, wird dreimal mit „Q-) abgeschlossen; Q-; Q-;" auf 'c' zeigen.

Wenn der Vektor -Instanziation CONT vorausgeht, kann kein Elementwert geändert werden. In diesem Fall muss der konstante Vorwärts -Iterator für das Ende oder mit dem Iterator mit Beginn zurückgegeben werden. Der folgende Code wird nicht kompiliert, da versucht wird, den Wert von 'C' zu ändern:

Const Vector vtr = 'a', 'b', 'c', 'd', 'e';
Vektor:: const_iterator q = vtr.Ende();
Q--; Q--; Q--;
*q = 'z';

Reverse Iteration

Reverse Iteration hat zwei Haupt -Iteratoren. Diese Iteratoren werden von den Mitgliedsfunktionen, rbegin () und rend () zurückgegeben. Rend () gibt einen Iterator zurück, der kurz vor dem ersten Element des Vektors zeigt. rbegin () gibt einen Iterator zurück, der auf das letzte Element des Vektors verweist. Der folgende Code liest und zeigt die Elemente des Vektors vom ersten bis zum letzten in die Vorwärtsrichtung an:

Vektor vtr = 'a', 'b', 'c', 'd', 'e';
Vektor>: Reverse_iterator p = vtr.zerreißen();
für (p = - -p; p> = vtr.rbegin (); P--)
Cout << *p << ";

Cout << endl;

Die Ausgabe ist:

A b c d e

Der umgekehrte Iterator wird verwendet. Da Rend () einen Iterator zurückgibt, der kurz vor dem ersten Element zeigt, das kein Element ist, muss er erhöht werden, um auf das erste Element zu verweisen. Da wir uns mit dem Reverse Iterator befassen, ist der Inkrementoperator hier - und nicht ++. Auch im Zustand wird> = anstelle von verwendet <= .

Der folgende Code liest und zeigt die Werte im Vektor vom letzten Element zum ersten Element unter Verwendung des Iterators von rBegin () an:

Vektor vtr = 'a', 'b', 'c', 'd', 'e';
für (Vektor:: Reverse_iterator q = vtr.rbegin (); Q <= vtr.rend(); q++)
Cout << *q << ";

Cout << endl;

Die Ausgabe ist:

E d c b a

Die Mitgliedsfunktion rbegin () gibt einen Iterator zurück, der auf das letzte Element des Vektors verweist. Der zurückgegebene Iterator ist ein Reverse_iterator. Rend () gibt einen Iterator zurück, der kurz vor dem ersten Element zeigt. Beachten. Dekrementierung mit diesem Iterator ist ++ und nicht -.

Wert eines Elements ändern

Wenn die Instanziierung des Vektors nicht von Const (für Konstante) vorausgeht, kann der Wert eines beliebigen Elements im Vektor mit dem Reverse_iterator geändert werden. Der folgende Code zeigt dies mit dem Reverse_iterator:

Vektor vtr = 'a', 'b', 'c', 'd', 'e';
Vektor:: Reverse_iterator q = vtr.rbegin ();
Q ++; Q ++;
*q = 'x';
für (Vektor:: Reverse_iterator r = vtr.rbegin (); R <= vtr.rend(); r++)
Cout << *r << ";

Cout << endl;

Die Ausgabe ist:

E d x b a

Der Rbegin () Iterator, Q wird zweimal mit „q ++; Q ++; “ auf 'c' zu zeigen, da es zunächst auf das letzte Element hinweist.

Wenn der Vektor -Instanziierung bei Const vorgegangen ist, kann mit einem Iterator kein Elementwert geändert werden, sei es Reverse_iterator Iterator (oder vorwärts). In diesem Fall muss der konstante umgekehrte Iterator für die Funktion rbegin () oder rend () zurückgegeben werden. Der folgende Code wird nicht kompiliert, da versucht wird, den Wert von 'C' zu ändern:

Const Vector vtr = 'a', 'b', 'c', 'd', 'e';
Vektor:: const_reverse_iterator q = vtr.rbegin ();
Q ++; Q ++;
*q = 'x';

Konstante umgekehrte Iterator

crbegin () verhält sich wie rbegin (), gibt jedoch einen const_reverse_iterator zurück, unabhängig davon, ob die Instanziierung des Vektors mit const begonnen wurde oder nicht. Dies bedeutet, dass der Wert des zurückgegebenen Iterators nicht geändert werden kann. crend ​​() verhält sich wie rend (), gibt jedoch einen const_reverse_iterator zurück, unabhängig davon, ob die Instanziierung des Vektors mit const begonnen wurde oder nicht. Dies bedeutet, dass der Wert des zurückgegebenen Iterators nicht geändert werden kann.

Der folgende Code zeigt alle Werte des Vektors mit const_reverse_iterator an, beginnend vom letzten Element:

Vektor vtr = 'a', 'b', 'c', 'd', 'e';
für (Vektor:: const_reverse_iterator q = vtr.crbegin (); Q <= vtr.crend(); q++)
Cout << *q << ";

Cout << endl;

Die Ausgabe ist:

E d c b a

Der folgende Code wird nicht kompiliert, da wir hier mit einem konstanten umgekehrten Iterator zu tun haben. Die Instanziierung des Vektors geht nicht von Const voraus.

Vektor vtr = 'a', 'b', 'c', 'd', 'e';
für (Vektor:: Reverse_iterator q = vtr.rbegin (); Q <= vtr.rend(); q++)
Cout << *q << ";

Cout << endl;

Abschluss

Ein Vektor kann wörtlich nicht umgekehrt werden. Es kann jedoch von hinten nach vorne iteriert werden, um ein ähnliches Ergebnis zu erzielen. Mit der Vorwärts -Iteration sind die Mitgliedsfunktionen, begin () und end () beteiligt. Im Fall einer umgekehrten Iteration sind Mitgliederfunktionen, rbegin () und Rend () beteiligt. In diesem Fall ist der beteiligte Iterator Reverse_iterator und kein Iterator. Noch in diesem Fall ist ++ - und> = ist <= . There is also const_reverse_iterator, for crbegin() and crend() member functions.