WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

std::prev — einen Iterator rückwärts bewegen

std::prev aus <iterator> gibt eine verschobene Kopie eines bidirektionalen Iterators zurück, ohne das Argument zu ändern. Standardmäßig bewegt sie ihn einen Schritt zurück; negatives n bedeutet eine Bewegung nach vorn. Der Aufrufer muss sicherstellen, dass die Bewegung innerhalb der gültigen Grenzen bleibt und bei der Auswertung von -n kein Überlauf auftritt.

Version: 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) gibt einen Iterator desselben Typs wie x zurück, der um n Schritte zurückbewegt wurde. Standardmäßig ist n gleich 1; n == 0 lässt die Position unverändert, und negatives n bewegt nach vorn. Die Funktion aus <iterator> arbeitet mit einer Kopie: Sie entspricht std::advance(x, -n); return x; und ändert daher den übergebenen Iterator nicht.

Ist der difference_type des Iterators ein schmaler vorzeichenbehafteter Ganzzahltyp, kann das unäre Minus n durch Ganzzahlpromotion zu int machen. Dann kann std::advance das Ergebnis als int erhalten, auch wenn es im ursprünglichen difference_type nicht darstellbar ist. Ist n dagegen der kleinste Wert eines vorzeichenbehafteten Ganzzahltyps, der nicht promoviert wird (etwa std::ptrdiff_t, sofern keine Promotion erfolgt), führt die Auswertung von -n zu einem vorzeichenbehafteten Überlauf und damit zu undefiniertem Verhalten, selbst wenn die beabsichtigte Bewegung innerhalb der gültigen Grenzen bliebe.

Der Typ muss die Anforderungen an bidirektionale Iteratoren erfüllen, auch wenn n negativ ist. Bei Iteratoren mit wahlfreiem Zugriff ist die Laufzeit konstant; bei anderen bidirektionalen Iteratoren ist sie linear zur Anzahl der Schritte. Das Ergebnis ist ein Iterator, kein Elementwert; falls sich das Ergebnis dereferenzieren lässt, kann das Element mit * gelesen werden.

Die Funktion prüft keine Grenzen. Bewege dich nicht vor den Anfang und nicht außerhalb des gültigen Bereichs. std::prev(values.end()) zeigt nur bei einem nicht leeren Container mit geeignetem Iterator auf das letzte Element; bei einem leeren Container ist dieser Schritt zurück ungültig. end() selbst kann nicht dereferenziert werden.

Verwechsle std::prev nicht mit std::ranges::prev: Letztere hat außerdem eine Überladung mit einer Grenze bound, die std::prev nicht bietet. Das Beispiel verwendet std::list<int> und zeigt die Bewegung zurück, die Bewegung nach vorn mit negativem n sowie den Erhalt des ursprünglichen Iterators.

Beispiele

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

Ergebnis

40 30 40
true

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen