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)
Definido en el encabezado <iterator>
Firma de llamada
template < std:: input_or_output_iterator I >
constexpr I next ( I i ) ;
(1) (desde C++20)
template < std:: input_or_output_iterator I >
constexpr I next ( I i, std:: iter_difference_t < I > n ) ;
(2) (desde C++20)
template < std:: input_or_output_iterator I, std:: sentinel_for < I > S >
constexpr I next ( I i, S bound ) ;
(3) (desde 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) (desde C++20)

Devuelve el n ésimo sucesor del iterador i .

Las entidades similares a funciones descritas en esta página son algorithm function objects (conocidas informalmente como niebloids ), es decir:

Contenidos

Parámetros

i - un iterador
n - número de elementos a avanzar
bound - centinela que denota el final del rango al que i apunta

Valor de retorno

1) El sucesor del iterador i .
2) El n ésimo sucesor del iterador i .
3) El primer iterador equivalente a bound .
4) El n ésimo sucesor del iterador i , o el primer iterador equivalente a bound , el que ocurra primero.

Complejidad

1) Constante.
2) Constante si I modela std::random_access_iterator ; de lo contrario, lineal.
3) Constante si I y S modelan tanto std:: random_access_iterator < I > como std:: sized_sentinel_for < S, I > , o si I y S modelan std:: assignable_from < I & , S > ; de lo contrario lineal.
4) Constante si I y S modelan ambos std:: random_access_iterator < I > y std:: sized_sentinel_for < S, I > ; de lo contrario lineal.

Implementación posible 

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();

Notas

Aunque la expresión ++ x. begin ( ) a menudo compila, no está garantizado que lo haga: x. begin ( ) es una expresión rvalue, y no existe ningún requisito que especifique que el incremento de un rvalue esté garantizado que funcione. En particular, cuando los iteradores se implementan como punteros o su operator++ está calificado como lvalue-ref, ++ x. begin ( ) no compila, mientras que ranges :: next ( x. begin ( ) ) sí lo hace.

Ejemplo

Ejecutar este código 
#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());
    }
}

Véase también

(C++20)
decrementa un iterador por una distancia dada o hasta un límite
(objeto función de algoritmo)
(C++20)
avanza un iterador por una distancia dada o hasta un límite dado
(objeto función de algoritmo)
(C++11)
incrementa un iterador
(plantilla de función)