Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::prev — spostare un iteratore all’indietro

std::prev, definita in <iterator>, restituisce una copia spostata di un iteratore bidirezionale senza modificare l’argomento. Per impostazione predefinita lo sposta indietro di un passo; un valore negativo di n indica uno spostamento in avanti. Chi la chiama deve assicurarsi che lo spostamento resti entro i limiti validi e che il calcolo di -n non causi un overflow.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

#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) restituisce un iteratore dello stesso tipo di x, spostato indietro di n passi. Il valore predefinito di n è 1; n == 0 lascia invariata la posizione, mentre un n negativo sposta in avanti. La funzione di <iterator> opera su una copia: equivale a std::advance(x, -n); return x;, quindi non modifica l’iteratore passato.

Se il difference_type dell’iteratore è un tipo intero con segno di larghezza ridotta, il meno unario può promuovere n a int. In tal caso std::advance può ricevere il risultato di tipo int anche se non è rappresentabile nel difference_type originale. Se invece n è il valore minimo di un tipo intero con segno non soggetto a promozione (per esempio std::ptrdiff_t quando non viene promosso), calcolare -n causa un overflow di un intero con segno e quindi un comportamento indefinito, anche se lo spostamento previsto rimarrebbe entro i limiti validi.

Il tipo deve soddisfare i requisiti degli iteratori bidirezionali, anche quando n è negativo. Gli iteratori ad accesso casuale richiedono tempo costante; gli altri iteratori bidirezionali richiedono tempo lineare rispetto al numero di passi. Il risultato è un iteratore, non il valore di un elemento; leggi l’elemento con * se il risultato è dereferenziabile.

La funzione non controlla i limiti. Non spostarti prima dell’inizio né al di fuori dell’intervallo valido. std::prev(values.end()) punta all’ultimo elemento solo per un contenitore non vuoto con un iteratore adeguato; questo passo all’indietro non è valido per un contenitore vuoto. Non è possibile dereferenziare end() stesso.

Non confondere std::prev con std::ranges::prev: quest’ultima dispone anche di un overload che accetta un limite bound, non disponibile in std::prev. L’esempio usa std::list<int> per mostrare lo spostamento all’indietro, quello in avanti con n negativo e la conservazione dell’iteratore originale.

Esempi

#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';
}

Risultato

40 30 40
true

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti