CKTIS / C++
std::prev — mover un iterador hacia atrás
std::prev, de <iterator>, devuelve una copia desplazada de un iterador bidireccional sin modificar el argumento. De forma predeterminada, lo mueve un paso hacia atrás; un n negativo significa avanzar. Quien llama debe asegurarse de que el movimiento respete los límites válidos y de que la evaluación de -n no provoque un desbordamiento.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
#include <iterator>
template<class BidirectionalIterator>
constexpr BidirectionalIterator prev(
BidirectionalIterator x,
typename std::iterator_traits<BidirectionalIterator>::difference_type n = 1);
std::prev(x)
std::prev(x, n)std::prev(x, n) devuelve un iterador del mismo tipo que x, desplazado n pasos hacia atrás. El valor predeterminado de n es 1; n == 0 deja la posición sin cambios y un n negativo mueve hacia delante. La función de <iterator> trabaja sobre una copia: equivale a std::advance(x, -n); return x;, por lo que no modifica el iterador proporcionado.
Si el difference_type del iterador es un tipo entero con signo de anchura reducida, el operador menos unario puede promover n a int. En ese caso, std::advance puede recibir el resultado de tipo int, aunque no se pueda representar en el difference_type original. En cambio, si n es el valor mínimo de un tipo entero con signo que no se promociona (por ejemplo, std::ptrdiff_t cuando no se promociona), evaluar -n provoca un desbordamiento de entero con signo y, por tanto, un comportamiento indefinido, aunque el desplazamiento previsto respetara los límites válidos.
El tipo debe cumplir los requisitos de los iteradores bidireccionales, incluso cuando n es negativo. Los iteradores de acceso aleatorio tardan un tiempo constante; los demás iteradores bidireccionales tardan un tiempo lineal respecto al número de pasos. El resultado es un iterador, no el valor de un elemento; lee el elemento con * si el resultado se puede desreferenciar.
La función no comprueba los límites. No te muevas antes del principio ni fuera del intervalo válido. std::prev(values.end()) apunta al último elemento solo si el contenedor no está vacío y tiene un iterador adecuado; ese paso hacia atrás no es válido para un contenedor vacío. No se puede desreferenciar el propio end().
No confundas std::prev con std::ranges::prev: esta última también tiene una sobrecarga que recibe un límite bound, que std::prev no ofrece. El ejemplo usa std::list<int> para mostrar el movimiento hacia atrás, el movimiento hacia delante con n negativo y la conservación del iterador original.
Ejemplos
#include <iostream>
#include <iterator>
#include <list>
int main() {
const std::list<int> values{10, 20, 30, 40};
const auto finish = values.end();
const auto last = std::prev(finish);
const auto earlier = std::prev(finish, 2);
const auto forward = std::prev(earlier, -1);
std::cout << *last << ' ' << *earlier << ' ' << *forward << '\n';
std::cout << std::boolalpha << (finish == values.end()) << '\n';
}
Resultado
40 30 40 true
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.