CKTIS / C++
std::prev — een iterator achteruit verplaatsen
std::prev uit <iterator> geeft een verschoven kopie van een bidirectionele iterator terug zonder het argument te wijzigen. Standaard verplaatst de functie deze één stap achteruit; een negatieve n betekent vooruit. De aanroeper moet ervoor zorgen dat de verplaatsing binnen de geldige grenzen blijft en dat het berekenen van -n geen overflow veroorzaakt.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
#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) geeft een iterator van hetzelfde type als x terug, n stappen achteruit verplaatst. De standaardwaarde van n is 1; n == 0 laat de positie ongewijzigd en een negatieve n verplaatst vooruit. De functie uit <iterator> werkt op een kopie: ze is gelijk aan std::advance(x, -n); return x; en wijzigt de meegegeven iterator dus niet.
Als het difference_type van de iterator een smal geheelgetaltype met teken is, kan de unaire minoperator n naar int promoveren. In dat geval kan std::advance het resultaat als int ontvangen, ook als het niet in het oorspronkelijke difference_type kan worden weergegeven. Is n daarentegen de kleinste waarde van een geheelgetaltype met teken dat niet wordt gepromoveerd (bijvoorbeeld std::ptrdiff_t wanneer er geen promotie plaatsvindt), dan veroorzaakt het berekenen van -n overflow van een geheel getal met teken en daarmee ongedefinieerd gedrag, zelfs als de beoogde verplaatsing binnen de geldige grenzen zou blijven.
Het type moet voldoen aan de eisen voor bidirectionele iterators, ook wanneer n negatief is. Random-access-iterators werken in constante tijd; andere bidirectionele iterators vergen tijd die lineair is met het aantal stappen. Het resultaat is een iterator, geen elementwaarde; lees het element met * als het resultaat kan worden gedereferentieerd.
De functie controleert geen grenzen. Verplaats niet voorbij het begin en niet buiten het geldige bereik. std::prev(values.end()) verwijst alleen naar het laatste element bij een niet-lege container met een geschikte iterator; die stap achteruit is ongeldig voor een lege container. end() zelf kan niet worden gedereferentieerd.
Verwar std::prev niet met std::ranges::prev: die laatste heeft ook een overload met een grens bound, die std::prev niet biedt. Het voorbeeld gebruikt std::list<int> om achteruit bewegen, vooruit bewegen met negatieve n en het behouden van de oorspronkelijke iterator te laten zien.
Voorbeelden
#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';
}
Resultaat
40 30 40 true
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.