Namespaces
Variants

std::ranges:: prev

From cppreference.net
C++
Iterator library
Iterator concepts
Iterator primitives
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
(C++20)
Iterator adaptors
Range access
(C++11) (C++14)
(C++14) (C++14)
(C++11) (C++14)
(C++14) (C++14)
(C++17) (C++20)
(C++17)
(C++17)
Definiert im Header <iterator>
Aufrufsignatur
template < std:: bidirectional_iterator I >
constexpr I prev ( I i ) ;
(1) (seit C++20)
template < std:: bidirectional_iterator I >
constexpr I prev ( I i, std:: iter_difference_t < I > n ) ;
(2) (seit C++20)
template < std:: bidirectional_iterator I >
constexpr I prev ( I i, std:: iter_difference_t < I > n, I bound ) ;
(3) (seit C++20)

Gib den n ten Vorgänger des Iterators i zurück.

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind algorithm function objects (informell bekannt als niebloids ), das heißt:

Inhaltsverzeichnis

Parameter

i - ein Iterator
n - Anzahl der Elemente, um die i verringert werden soll
bound - Iterator, der den Anfang des Bereichs bezeichnet, auf den i zeigt

Rückgabewert

1) Der Vorgänger von i .
2) Der n te Vorgänger des Iterators i .
3) Der n te Vorgänger des Iterators i , oder der erste Iterator, der gleich bound ist, je nachdem, was zuerst eintritt.

Komplexität

1) Konstante.
2,3) Konstant, falls I das Konzept std:: random_access_iterator < I > modelliert; andernfalls linear.

Mögliche Implementierung 

struct prev_fn
{
    template<std::bidirectional_iterator I>
    constexpr I operator()(I i) const
    {
        --i;
        return i;
    }
    template<std::bidirectional_iterator I>
    constexpr I operator()(I i, std::iter_difference_t<I> n) const
    {
        ranges::advance(i, -n);
        return i;
    }
    template<std::bidirectional_iterator I>
    constexpr I operator()(I i, std::iter_difference_t<I> n, I bound) const
    {
        ranges::advance(i, -n, bound);
        return i;
    }
};
inline constexpr auto prev = prev_fn();

Hinweise

Obwohl der Ausdruck -- r. end ( ) für Container häufig kompiliert, ist dies nicht garantiert: r. end ( ) ist ein Rvalue-Ausdruck, und es gibt keine Iterator-Anforderung, die spezifiziert, dass die Dekrementierung eines Rvalues garantiert funktioniert. Insbesondere wenn Iteratoren als Zeiger implementiert sind oder deren operator-- Lvalue-Ref-qualifiziert ist, -- r. end ( ) kompiliert nicht, während ranges :: prev ( r. end ( ) ) dies tut.

Dies wird weiter verschärft durch Bereiche, die kein ranges:: common_range modellieren. Beispielsweise hat für einige zugrundeliegende Bereiche ranges :: transform_view :: end nicht den gleichen Rückgabetyp wie ranges :: transform_view :: begin , und deshalb wird -- r. end ( ) nicht kompilieren. Dies ist nichts, wobei ranges::prev helfen kann, aber es gibt Lösungsansätze.

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <iterator>
#include <vector>
int main() 
{
    std::vector<int> v{3, 1, 4};
    auto pv = std::ranges::prev(v.end(), 2);
    std::cout << *pv << '\n';
    pv = std::ranges::prev(pv, 42, v.begin());
    std::cout << *pv << '\n';
}

Ausgabe: 

1
3

Siehe auch

(C++20)
Erhöht einen Iterator um eine gegebene Distanz oder bis zu einer Grenze
(Algorithmus-Funktionsobjekt)
(C++20)
Bewegt einen Iterator um eine gegebene Distanz oder bis zu einer Grenze
(Algorithmus-Funktionsobjekt)
(C++11)
Verringert einen Iterator
(Funktionstemplate)