std::anterior en C++

std::prev devuelve un iterador que apunta al elemento después de haber avanzado una cierta cantidad de posiciones en la dirección inversa. Se define dentro del iterador del archivo de cabecera . Devuelve una copia del argumento avanzado por la cantidad especificada en la dirección hacia atrás. Si es un iterador de acceso aleatorio, la función usa solo una vez el operador + o el operador – para avanzar. De lo contrario, la función usa repetidamente el operador de aumento o disminución (operador ++ u operador – -) en el iterador copiado hasta que se hayan avanzado n elementos. Sintaxis:

BidirectionalIterator prev (BidirectionalIterator it,
       typename iterator_traits::difference_type n = 1);
it: Iterator to the base position.
difference_type: It is the numerical type that represents 
distances between iterators of the BidirectionalIterator type.
n: Total no. of positions by which the
iterator has to be advanced. In the syntax, n is assigned
a default value 1 so it will atleast advance by 1 position.

Returns: It returns an iterator to the element 
n positions before it.

// C++ program to demonstrate std::prev
#include <iostream>
#include <iterator>
#include <deque>
#include <algorithm>
using namespace std;
int main()
{
    // Declaring first container
    deque<int> v1 = { 1, 2, 3, 4, 5, 6, 7 };
 
    // Declaring another container
    deque<int> v2 = { 8, 9, 10 };
 
    // Declaring an iterator
    deque<int>::iterator i1;
 
    // i1 points to 1
    i1 = v1.begin();
 
    // Declaring another iterator to store return
    // value and using std::prev
    deque<int>::iterator i2;
    i2 = std::prev(v1.end(), 3);
 
    // Using std::copy
    std::copy(i1, i2, std::back_inserter(v2));
    // Remember, i1 stills points to 1
    // and i2 points to 5
    // v2 now contains 8 9 10 1 2 3 4
 
    // Displaying v1 and v2
    cout << "v1 = ";
 
    int i;
    for (i = 0; i < 7; ++i) {
        cout << v1[i] << " ";
    }
 
    cout << "\nv2 = ";
    for (i = 0; i < 7; ++i) {
        cout << v2[i] << " ";
    }
 
    return 0;
}

Producción:

v1 = 1 2 3 4 5 6 7
v2 = 8 9 10 1 2 3 4

¿Cómo puede ser útil?

• Mover el iterador en las listas: dado que las listas admiten iteradores bidireccionales , que solo se pueden incrementar mediante el uso de los operadores ++ y –. Entonces, si queremos avanzar el iterador en más de una posición, entonces std::next y si queremos disminuir el iterador, entonces std::prev puede ser extremadamente útil. 

// C++ program to demonstrate std::prev
#include <iostream>
#include <iterator>
#include <list>
#include <algorithm>
using namespace std;
int main()
{
    // Declaring first container
    list<int> v1 = { 1, 2, 3, 7, 8, 9 };
 
    // Declaring second container
    list<int> v2 = { 4, 5, 6 };
 
    list<int>::iterator i1;
    i1 = v1.begin();
    // i1 points to 1 in v1
 
    list<int>::iterator i2;
    // i2 = v1.end() - 3;
    // This cannot be used with lists
    // so use std::prev for this
 
    i2 = std::prev(v1.end(), 3);
 
    // Using std::copy
    std::copy(i1, i2, std::back_inserter(v2));
    // v2 now contains 4 5 6 1 2 3
 
    // Displaying v1 and v2
    cout << "v1 = ";
 
    int i;
    for (i1 = v1.begin(); i1 != v1.end(); ++i1) {
        cout << *i1 << " ";
    }
 
    cout << "\nv2 = ";
    for (i1 = v2.begin(); i1 != v2.end(); ++i1) {
        cout << *i1 << " ";
    }
 
    return 0;
}

• Producción:

v1 = 1 2 3 7 8 9
v2 = 4 5 6 1 2 3 

• Explicación: aquí, solo mire cómo si queremos copiar solo una parte seleccionada de la lista, entonces podemos usar std::prev, ya que de lo contrario no podemos usar ningún operador +=, -= con iteradores bidireccionales admitidos por listas. Entonces, usamos std::prev y movimos directamente el iterador hacia atrás tres posiciones desde el final.

¿Podemos usar std::next en lugar de std::prev?

Una consulta común que puede surgir con std::prev es que std::next también se puede usar con un argumento negativo para mover el iterador hacia atrás. Bueno, la respuesta es sí . 

// C++ program to demonstrate std::next
#include <iostream>
#include <iterator>
#include <deque>
#include <algorithm>
using namespace std;
int main()
{
    // Declaring first container
    deque<int> v1 = { 1, 2, 3, 4, 5, 6, 7 };
 
    // Declaring another container
    deque<int> v2 = { 8, 9, 10 };
 
    // Declaring an iterator
    deque<int>::iterator i1;
 
    // i1 points to 1
    i1 = v1.begin();
 
    // Declaring another iterator to store return
    // value and using std::next
    deque<int>::iterator i2;
    i2 = std::next(v1.end(), -3);
 
    // Using std::copy
    std::copy(i1, i2, std::back_inserter(v2));
    // Remember, i1 stills points to 1
    // and i2 points to 5
    // v2 now contains 8 9 10 1 2 3 4
 
    // Displaying v1 and v2
    cout << "v1 = ";
 
    int i;
    for (i = 0; i < 7; ++i) {
        cout << v1[i] << " ";
    }
 
    cout << "\nv2 = ";
    for (i = 0; i < 7; ++i) {
        cout << v2[i] << " ";
    }
 
    return 0;
}

Producción:

v1 = 1 2 3 4 5 6 7
v2 = 8 9 10 1 2 3 4

Explicación: Entonces, acabamos de usar std::next en lugar de std::prev y cambiamos el segundo argumento de 3 a -3 aquí y todavía sirve para el mismo propósito. También podemos usar std::next, pero hay dos cosas que deben tenerse en cuenta:

• Dado que, std::next en su sintaxis tiene un argumento como iterador hacia adelante, por lo que si queremos usar un no negativo. para avanzar ese iterador, entonces debería ser al menos un iterador bidireccional .
• Aunque también se puede usar std::next, pero std::prev() sería más legible cuando la intención es específicamente retroceder.

Este artículo es una contribución de Mrigendra Singh . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.