Cómo revertir un vector en C ++

Si un vector tiene elementos en la secuencia, 'a', 'b', 'c', 'd', 'e' y se reconfigura de tal manera que su secuencia se convierte en 'e', 'd', ' C ',' b ',' a ' Entonces el vector ha sido invertido. Desafortunadamente, tal reversibilidad directa no es posible en C++. Sin embargo, un vector en C ++ puede ser iterado desde la parte posterior, y eso es una reversibilidad indirecta. Con eso, no hay necesidad de revertir el vector literalmente. Este artículo explica cómo iterar un vector en C ++ desde la parte posterior y modificar sus elementos.

Antes de usar un vector en C ++, el programa debe comenzar con,

#incluir
#incluir
usando el espacio de nombres STD;

con la biblioteca vectorial incluida. Es más fácil entender la iteración inversa después de tener un resumen de la iteración de reenvío. Por lo tanto, se resume primero la iteración hacia adelante antes de explicar la iteración inversa.

Contenido del artículo

• Iteración hacia adelante
• Iteración inversa
• Iterador inverso constante
• Conclusión

Iteración hacia adelante

Iteración de avance con dos iteradores. Un iterador es un objeto de puntero elaborado con características especiales. Aquí, los dos iteradores de interés son devueltos por la función de miembro Begin () y la función miembro final (). La función de miembro begin () devuelve un iterador que apunta al primer elemento del vector. La función de miembro final () devuelve un iterador que apunta justo más allá del último elemento del vector.

Suponga que el nombre del vector es VTR, entonces la siguiente declaración devolverá un iterador de comienzo:

vector:: iterador p = vtr.comenzar();

donde p es el nombre dado al iterador de comienzo. La siguiente declaración devolverá un iterador final:

vector:: iterator q = VTR.fin();

Donde Q es el nombre dado al iterador final, se puede ver en las dos declaraciones anteriores que P y Q son del mismo tipo e incluso se pueden intercambiar.

Todos los segmentos de código para este artículo están escritos en la función Main (). El siguiente código lee todos los elementos del vector, desde el principio hasta el último elemento:

vector vtr = 'a', 'b', 'c', 'd', 'e';
para (vector:: iterador p = vtr.comenzar(); pag != VTR.fin(); p ++)
cout << *p << ";

cout < vtr = 'A', 'B', 'C', 'D', 'E';
vector:: iterator q = VTR.fin();
para (q = --q; q> = vtr.comenzar(); q--)
cout << *q << ";

cout << endl;

La salida es:

A B C D E

El código entre paréntesis de la explicación del bucle for-bucle necesita. P es un iterador que primero apunta al primer elemento del vector. Si bien aún no apunta más allá del vector, P ++ lo incrementa apuntar a cada elemento en el vector. Cuando apunta a un elemento en el vector, el valor (carácter) del elemento se obtiene con *P en el cuerpo del bucle for-bucle. * es el operador de indirección.

El siguiente código lee y muestra los valores en el vector desde el último elemento hasta el primer elemento, utilizando el iterador final:

vectorvtr = 'a', 'b', 'c', 'd', 'e';
vector:: iterator q = VTR.fin();
para (q = --q; q> = vtr.comenzar(); q--)
cout << *q << ";

cout << endl;

La salida es:

E D C B A

El iterador final apunta justo más allá del final del vector, y ese no es un elemento. Por lo tanto, debe disminuir primero antes de que pueda apuntar al último elemento. A partir de ahí, la iteración puede retroceder.

La condición de tiempo para el for-bucle aquí es: "Si Q es mayor o igual que el iterador inicial". No puede ser "si Q no es igual al iterador inicial", ya que eso excluiría el primer elemento.

Esta es una forma informal de iterar hacia atrás. Es decir, esta es una forma informal de revertir un vector indirectamente.

Cambiar el valor de un elemento

Cuando la instanciación del vector no está precedida por const (para constante), el valor de cualquier elemento en el vector se puede cambiar. El siguiente código ilustra esto:

vector vtr = 'a', 'b', 'c', 'd', 'e';
vector:: iterator q = VTR.fin();
Q--; Q--; Q--;
*q = 'z';
vector:: iterator r = vtr.fin();
para (r = -r; r> = vtr.comenzar(); r--)
cout << *r << ";

cout << endl;

La salida es:

E D Z B A

El iterador final, Q se disminuye tres veces con "Q-; Q-; Q-; " apuntar a 'c'.

Si la instanciación del vector se precede con const, entonces no se puede cambiar ningún valor de elemento. En este caso, el iterador constante delantero debe devolverse para el final o el iterador de comienzo. El siguiente código no se compilará porque se intenta cambiar el valor de 'C':

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

Iteración inversa

La iteración inversa tiene dos iteradores principales. Estos iteradores son devueltos por las funciones de los miembros, rbegin () y rend (). rend () Devuelve un iterador que apunta justo en frente del primer elemento del vector. rbegin () Devuelve un iterador que apunta al último elemento del vector. El siguiente código lee y muestra los elementos del vector, desde el primero hasta el último, en la dirección de avance:

vector vtr = 'a', 'b', 'c', 'd', 'e';
vector>: reverse_iterator p = vtr.desgarrar();
para (p = -p; p> = vtr.rbegin (); pag--)
cout << *p << ";

cout << endl;

La salida es:

A B C D E

Se utiliza el iterador inverso. Dado que Rend () devuelve un iterador que apunta justo en frente del primer elemento, que no es un elemento, debe incrementarse para apuntar al primer elemento. Dado que estamos tratando con el iterador inverso, el operador de incremento aquí es, y no ++. Además, en la condición de tiempo,> = se usa en lugar de <= .

El siguiente código lee y muestra los valores en el vector, desde el último elemento hasta el primer elemento, utilizando el iterador de rbegin ()::

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

cout << endl;

La salida es:

E D C B A

La función miembro rbegin () devuelve un iterador que apunta al último elemento del vector. El iterador devuelto es un reverse_iterator. rend () Devuelve un iterador que apunta justo antes del primer elemento. Tenga en cuenta que la condición de tiempo para el bucle tiene but =, ya que estamos tratando con un iterador inverso. La disminución con este iterador es ++ y no -.

Cambiar el valor de un elemento

Cuando la instancia del vector no está precedida por const (para constante), el valor de cualquier elemento en el vector se puede cambiar con el reverso_iterator. El siguiente código ilustra esto, con el reverso_iterator:

vector vtr = 'a', 'b', 'c', 'd', 'e';
vector:: reverse_iterator q = vtr.rbegin ();
Q ++; Q ++;
*q = 'x';
para (vector:: reverse_iterator r = vtr.rbegin (); riñonal <= vtr.rend(); r++)
cout << *r << ";

cout << endl;

La salida es:

E D X B A

El iterador de rbegin (), Q se disminuye dos veces con "Q ++; Q ++; " apuntar en 'c', ya que inicialmente apunta al último elemento.

Si la instanciación del vector se precede con const, entonces no se puede cambiar ningún valor de elemento, con un iterador, ya sea ITERATOR DE INVERSED_ITERATOR (o avance). En este caso, el iterador inverso constante debe devolverse para la función rbegin () o rend (). El siguiente código no se compilará porque se intenta cambiar el valor de 'C':

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

Iterador inverso constante

crbegin () se comporta como rbegin (), pero devuelve un const_reverse_iterator, si la instancia del vector se inició o no con const. Esto significa que el valor del iterador devuelto no se puede cambiar. crend ​​() se comporta como rend (), pero devuelve un const_reverse_iterator, si la instanciación del vector se inició o no con const. Esto significa que el valor del iterador devuelto no se puede cambiar.

El siguiente código muestra todos los valores del vector, usando const_reverse_iterator, comenzando desde el último elemento:

vector vtr = 'a', 'b', 'c', 'd', 'e';
para (vector:: const_reverse_iterator q = vtr.crbegin (); Q <= vtr.crend(); q++)
cout << *q << ";

cout << endl;

La salida es:

E D C B A

El siguiente código no se compilará porque estamos tratando aquí con un iterador inverso constante. La instancia del vector no está precedida por const.

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

cout << endl;

Conclusión

Un vector no se puede revertir literalmente. Sin embargo, se puede iterarse de regreso a delante para tener un resultado similar. Con la iteración hacia adelante, las funciones del miembro, Begin () y End () están involucrados. En el caso de la iteración inversa, las funciones miembros, rbegin () y rend () están involucrados. En este caso, el iterador involucrado es reverse_iterator y no un iterador. Aún en este caso, ++ es - y> = es <= . There is also const_reverse_iterator, for crbegin() and crend() member functions.