Come invertire un vettore in C ++

Se un vettore ha elementi nella sequenza, 'a', 'b', 'c', 'd', 'e' ed è riconfigurato in modo tale che la sua sequenza diventi, 'e', 'd', ' C ',' b ',' a ' Quindi il vettore è stato invertito. Sfortunatamente, tale reversibilità diretta non è possibile in C++. Tuttavia, un vettore in C ++ può essere iterato da dietro, e questa è reversibilità indiretta. Con ciò, non è necessario invertire letteralmente il vettore. Questo articolo spiega come iterare un vettore in C ++ dalla parte posteriore e modificare i suoi elementi.

Prima di utilizzare un vettore in C ++, il programma dovrebbe iniziare con,

#includere
#includere
Utilizzo dello spazio dei nomi std;

con la libreria vettoriale inclusa. È più facile comprendere l'iterazione inversa dopo aver avuto un riepilogo dell'ivalutazione. Quindi l'iterazione in avanti è riassunta prima di spiegare l'iterazione inversa.

Contenuto dell'articolo

• Iterazione in avanti
• Iterazione inversa
• Iteratore inverso costante
• Conclusione

Iterazione in avanti

L'iterazione in avanti si occupa di due iteratori. Un iteratore è un oggetto puntatore elaborato con caratteristiche speciali. Qui, i due iteratori di interesse vengono restituiti dalla funzione membro Begin () e dalla funzione membro end (). La funzione membro Begin () restituisce un iteratore che indica il primo elemento del vettore. La funzione membro end () restituisce un iteratore che punta appena oltre l'ultimo elemento del vettore.

Supponiamo che il nome del vettore sia VTR, quindi la seguente dichiarazione restituirà un Iteratore iniziale:

vettore:: iterator p = vtr.inizio();

dove p è il nome dato all'inizio iteratore. La seguente dichiarazione restituirà un iteratore finale:

vettore:: iteratore Q = VTR.FINE();

dove q è il nome dato all'iteratore finale, può essere visto dalle due affermazioni sopra che P e Q sono dello stesso tipo e possono anche essere scambiati.

Tutti i segmenti di codice per questo articolo sono scritti nella funzione principale (). Il seguente codice legge tutti gli elementi del vettore, dall'inizio all'ultimo elemento:

vettore vtr = 'a', 'b', 'c', 'd', 'e';
per (vettore:: iterator p = vtr.inizio(); P != vtr.FINE(); p ++)
cout << *p << ";

cout < vtr = 'A', 'B', 'C', 'D', 'E';
vettore:: iteratore Q = VTR.FINE();
per (q = --q; q> = vtr.inizio(); Q--)
cout << *q << ";

cout << endl;

L'output è:

A b c d e

Il codice tra parentesi del per loop necessita di spiegazioni. P è un iteratore che i primi indicano il primo elemento del vettore. Sebbene non sia ancora puntato appena oltre il vettore, è incrementato da p ++ puntare a ciascun elemento nel vettore. Quando indica un elemento nel vettore, il valore (carattere) dell'elemento si ottiene con *p nel corpo del per loop per loop. * è l'operatore indirezione.

Il seguente codice legge e visualizza i valori nel vettore dall'ultimo elemento al primo elemento, usando l'iteratore finale:

vettorevtr = 'a', 'b', 'c', 'd', 'e';
vettore:: iteratore Q = VTR.FINE();
per (q = --q; q> = vtr.inizio(); Q--)
cout << *q << ";

cout << endl;

L'output è:

E d c b a

L'eteratore finale punta appena oltre la fine del vettore, e questo non è un elemento. Quindi, deve essere decrementato prima di poter indicare l'ultimo elemento. Da lì, l'iterazione può andare all'indietro.

La condizione di while per il per loop qui è: "Se Q è maggiore o uguale all'inizio Iteratore". Non può essere "se Q non è uguale all'inizio dell'iteratore", in quanto ciò escluderebbe il primo elemento.

Questo è un modo informale per iterare l'indietro. Cioè, questo è un modo informale per invertire un vettore indirettamente.

Modifica del valore di un elemento

Quando l'istanziazione del vettore non è preceduta da const (per costante), il valore di qualsiasi elemento nel vettore può essere modificato. Il seguente codice illustra questo:

vettore vtr = 'a', 'b', 'c', 'd', 'e';
vettore:: iteratore Q = VTR.FINE();
Q--; Q--; Q--;
*q = 'z';
vettore:: iterator r = vtr.FINE();
per (r = - -r; r> = vtr.inizio(); R--)
cout << *r << ";

cout << endl;

L'output è:

E d z b a

L'iteratore finale, Q viene decrementato tre volte con “Q-; Q-; Q-;" puntare a 'c'.

Se l'istanziazione vettoriale è preceduta con const, non è possibile modificare alcun valore dell'elemento. In questo caso, il costante iteratore in avanti deve essere restituito per la fine o inizio iteratore. Il seguente codice non si compilerà perché viene fatto un tentativo di modificare il valore di "C":

const vector vtr = 'a', 'b', 'c', 'd', 'e';
vettore:: const_iterator q = vtr.FINE();
Q--; Q--; Q--;
*q = 'z';

Iterazione inversa

L'iterazione inversa ha due iteratori principali. Questi iteratori vengono restituiti dalle funzioni del membro, rbegin () e Rend (). Rend () restituisce un iteratore che punta proprio davanti al primo elemento del vettore. rbegin () restituisce un iteratore che punta all'ultimo elemento del vettore. Il seguente codice legge e visualizza gli elementi del vettore, dal primo all'ultimo, nella direzione in avanti:

vettore vtr = 'a', 'b', 'c', 'd', 'e';
vettore>: reverse_iterator p = vtr.rend ();
per (p = - -p; p> = vtr.rbegin (); P--)
cout << *p << ";

cout << endl;

L'output è:

A b c d e

Viene utilizzato l'iteratore inverso. Poiché Rend () restituisce un iteratore che punta proprio davanti al primo elemento, che non è un elemento, deve essere incrementato per indicare il primo elemento. Dal momento che abbiamo a che fare con l'iteratore inverso, l'operatore di incremento qui è - e non ++. Inoltre, nella condizione di tempo,> = viene utilizzato al posto di <= .

Il seguente codice legge e visualizza i valori nel vettore, dall'ultimo elemento al primo elemento, usando l'iteratore di rbegin ():

vettore vtr = 'a', 'b', 'c', 'd', 'e';
per (vettore:: reverse_iterator Q = VTR.rbegin (); Q <= vtr.rend(); q++)
cout << *q << ";

cout << endl;

L'output è:

E d c b a

La funzione membro rbegin () restituisce un iteratore che indica l'ultimo elemento del vettore. L'iteratore restituito è un reverse_iterator. Rend () restituisce un iteratore che punta appena prima del primo elemento. Si noti che la condizione while per il per loop ha ma =, poiché abbiamo a che fare con un iteratore inverso. Il decremento con questo iteratore è ++ e non -.

Modifica del valore di un elemento

Quando l'istanza del vettore non è preceduta da const (per costante), il valore di qualsiasi elemento nel vettore può essere modificato con il reverse_iterator. Il seguente codice lo illustra, con il reverse_iterator:

vettore vtr = 'a', 'b', 'c', 'd', 'e';
vettore:: reverse_iterator Q = VTR.rbegin ();
Q ++; Q ++;
*q = 'x';
per (vettore:: reverse_iterator r = vtr.rbegin (); R <= vtr.rend(); r++)
cout << *r << ";

cout << endl;

L'output è:

E d x b a

L'iteratore rbegin (), Q viene decrementato due volte con “Q ++; Q ++; " puntare a 'c', poiché inizialmente indica l'ultimo elemento.

Se l'istanziazione vettoriale è preceduta con const, non è possibile modificare alcun valore dell'elemento, con un iteratore, che si tratti di iteratore di reverse_iterator (o in avanti). In questo caso, l'iteratore inverso costante deve essere restituito per la funzione rbegin () o rend (). Il seguente codice non si compilerà perché viene fatto un tentativo di modificare il valore di "C":

const vector vtr = 'a', 'b', 'c', 'd', 'e';
vettore:: const_reverse_iterator Q = VTR.rbegin ();
Q ++; Q ++;
*q = 'x';

Iteratore inverso costante

Crbegin () si comporta come rbegin (), ma restituisce un const_reverse_iterator, indipendentemente dal fatto che l'istanziazione del vettore sia stata iniziata con const. Ciò significa che il valore dell'iteratore restituito non può essere modificato. cred () si comporta come rend (), ma restituisce un const_reverse_iterator, indipendentemente dal fatto che l'istanziazione del vettore sia stata iniziata con const. Ciò significa che il valore dell'iteratore restituito non può essere modificato.

Il seguente codice visualizza tutti i valori del vettore, usando const_reverse_iterator, a partire dall'ultimo elemento:

vettore vtr = 'a', 'b', 'c', 'd', 'e';
per (vettore:: const_reverse_iterator Q = VTR.Crbegin (); Q <= vtr.crend(); q++)
cout << *q << ";

cout << endl;

L'output è:

E d c b a

Il seguente codice non si compilerà perché stiamo trattando qui con un iteratore inverso costante. L'istanziazione del vettore non è preceduta da const.

vettore vtr = 'a', 'b', 'c', 'd', 'e';
per (vettore:: reverse_iterator Q = VTR.rbegin (); Q <= vtr.rend(); q++)
cout << *q << ";

cout << endl;

Conclusione

Un vettore non può essere invertito letteralmente. Tuttavia, può essere iterato da dietro al fronte per avere un risultato simile. Con l'iterazione in avanti, le funzioni del membro, inizio () e fine () sono coinvolte. In caso di iterazione inversa, sono coinvolte funzioni membri, rbegin () e rend (). In questo caso, l'iteratore coinvolto è reverse_iterator e non un iteratore. Ancora in questo caso, ++ è - e> = è <= . There is also const_reverse_iterator, for crbegin() and crend() member functions.