База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / C++

std::prev — преместване на итератор назад

std::prev от <iterator> връща изместено копие на двупосочен итератор, без да променя аргумента. По подразбиране го премества с една стъпка назад; отрицателно n означава движение напред. Извикващият трябва да гарантира, че движението остава в допустимите граници и че изчисляването на -n не води до препълване.

Версия: C++23; repository compiler flag, production runtime not attested

Синтаксис

#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) връща итератор от същия тип като x, преместен с n стъпки назад. Стойността по подразбиране на n е 1; n == 0 оставя позицията непроменена, а отрицателно n премества напред. Функцията от <iterator> работи с копие: тя е еквивалентна на std::advance(x, -n); return x;, затова не променя подадения итератор.

Ако difference_type на итератора е тесен целочислен тип със знак, унарният минус може да предизвика целочислена промоция на n до int. В този случай std::advance може да получи резултата от тип int, дори ако той не може да се представи в първоначалния difference_type. Но ако n е най-малката стойност на целочислен тип със знак, който не подлежи на промоция (например std::ptrdiff_t, когато няма промоция), изчисляването на -n води до препълване на цяло число със знак и съответно до неопределено поведение, дори ако предвиденото преместване би останало в допустимите граници.

Типът трябва да отговаря на изискванията за двупосочни итератори, дори когато n е отрицателно. Итераторите с произволен достъп работят за постоянно време; за останалите двупосочни итератори времето е линейно спрямо броя стъпки. Резултатът е итератор, а не стойност на елемент; прочетете елемента с *, ако резултатът може да се дереферира.

Функцията не проверява границите. Не се придвижвайте преди началото или извън допустимия диапазон. std::prev(values.end()) сочи към последния елемент само при непразен контейнер с подходящ итератор; тази стъпка назад е невалидна за празен контейнер. Самият end() не може да се дереферира.

Не бъркайте std::prev с std::ranges::prev: последната има и претоварване, което приема граница bound, каквато std::prev не предлага. Примерът използва std::list<int>, за да покаже движение назад, движение напред с отрицателно n и запазване на първоначалния итератор.

Примери

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

Резултат

40 30 40
true

Показаният код и заявеният резултат са проверени в изолирана среда по метода, записан в доказателството за проверка на тази точна версия.

Източници