Namespaces
Variants

std::ranges:: next

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:: input_or_output_iterator I >
constexpr I next ( I i ) ;
(1) (seit C++20)
template < std:: input_or_output_iterator I >
constexpr I next ( I i, std:: iter_difference_t < I > n ) ;
(2) (seit C++20)
template < std:: input_or_output_iterator I, std:: sentinel_for < I > S >
constexpr I next ( I i, S bound ) ;
(3) (seit C++20)
template < std:: input_or_output_iterator I, std:: sentinel_for < I > S >
constexpr I next ( I i, std:: iter_difference_t < I > n, S bound ) ;
(4) (seit C++20)

Gib den n ten Nachfolger 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 zu überspringenden Elemente
bound - Sentinel, der das Ende des Bereichs markiert, i auf den zeigt

Rückgabewert

1) Der Nachfolger des Iterators i .
2) Der n te Nachfolger des Iterators i .
3) Der erste Iterator, der gleich bound ist.
4) Der n te Nachfolger des Iterators i , oder der erste Iterator, der gleichwertig zu bound ist, je nachdem, was zuerst eintritt.

Komplexität

1) Konstante.
2) Konstant, falls I std::random_access_iterator modelliert; andernfalls linear.
3) Konstant, wenn I und S beide std:: random_access_iterator < I > und std:: sized_sentinel_for < S, I > modellieren, oder wenn I und S std:: assignable_from < I & , S > modellieren; andernfalls linear.
4) Konstant, falls I und S beide std:: random_access_iterator < I > und std:: sized_sentinel_for < S, I > modellieren; andernfalls linear.

Mögliche Implementierung 

struct next_fn
{
    template<std::input_or_output_iterator I>
    constexpr I operator()(I i) const
    {
        ++i;
        return i;
    }
    template<std::input_or_output_iterator I>
    constexpr I operator()(I i, std::iter_difference_t<I> n) const
    {
        ranges::advance(i, n);
        return i;
    }
    template<std::input_or_output_iterator I, std::sentinel_for<I> S>
    constexpr I operator()(I i, S bound) const
    {
        ranges::advance(i, bound);
        return i;
    }
    template<std::input_or_output_iterator I, std::sentinel_for<I> S>
    constexpr I operator()(I i, std::iter_difference_t<I> n, S bound) const
    {
        ranges::advance(i, n, bound);
        return i;
    }
};
inline constexpr auto next = next_fn();

Hinweise

Obwohl der Ausdruck ++ x. begin ( ) oft kompiliert, ist dies nicht garantiert: x. begin ( ) ist ein Rvalue-Ausdruck, und es gibt keine Anforderung, die festlegt, dass die Inkrementierung eines Rvalues garantiert funktioniert. Insbesondere wenn Iteratoren als Zeiger implementiert sind oder deren operator++ Lvalue-Ref-qualifiziert ist, ++ x. begin ( ) kompiliert nicht, während ranges :: next ( x. begin ( ) ) dies tut.

Beispiel

Diesen Code ausführen 
#include <cassert>
#include <iterator>
int main() 
{
    auto v = {3, 1, 4};
    {
        auto n = std::ranges::next(v.begin());
        assert(*n == 1);
    }
    {
        auto n = std::ranges::next(v.begin(), 2);
        assert(*n == 4);
    }
    {
        auto n = std::ranges::next(v.begin(), v.end());
        assert(n == v.end());
    }
    {
        auto n = std::ranges::next(v.begin(), 42, v.end());
        assert(n == v.end());
    }
}

Siehe auch

(C++20)
Dekrementiert 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 bestimmten Grenze
(Algorithmus-Funktionsobjekt)
(C++11)
Inkrementiert einen Iterator
(Funktionstemplate)