std::ranges::rbegin

inline namespace /* unspecified */ {
    inline constexpr /* unspecified */ rbegin = /* unspecified */;
}

template< class T >
    requires /* see below */
constexpr std::input_or_output_iterator auto rbegin( T&& t );

Devuelve un iterador al último elemento del argumento.

Si T es un tipo array y std::remove_all_extents_t<std::remove_reference_t<T>> está incompleto, entonces la llamada a ranges::rbegin está mal formada, no se requiere diagnóstico.

Si el argumento es un valor l o ranges::enable_borrowed_range<std::remove_cv_t<T>> es true, entonces una llamada a ranges::rbegin es equivalente en expresión a:

1. decay-copy(t.rbegin())(hasta C++23)auto(t.rbegin())(desde C++23), si esa expresión es válida y su tipo satisface std::input_or_output_iterator.
2. De lo contrario, decay-copy(rbegin(t))(hasta C++23)auto(rbegin(t))(desde C++23), si T es de tipo clase o enumeración, esa expresión es válida y su tipo satisface std::input_or_output_iterator, donde el significado de rbegin se establece como si se realizara una búsqueda dependiente de argumentos únicamente.
3. De lo contrario, std::make_reverse_iterator(ranges::end(t)) si tanto ranges::begin(t) como ranges::end(t) son expresiones válidas, tienen el mismo tipo, y ese tipo satisface std::bidirectional_iterator.

En todos los demás casos, una llamada a ranges::rbegin está mal formada, lo que puede resultar en un fallo de sustitución cuando ranges::rbegin(t) aparece en el contexto inmediato de una instanciación de plantilla.

Objetos de punto de personalización

El nombre ranges::rbegin denota un objeto punto de personalización , que es un objeto función constante de tipo clase literal semiregular . Consulte CustomizationPointObject para más detalles.

Notas

Si el argumento es un rvalue (es decir, T es un tipo objeto) y ranges:: enable_borrowed_range < std:: remove_cv_t < T >> es false , la llamada a ranges::rbegin está mal formada, lo que también resulta en fallo de sustitución.

El tipo de retorno modela std::input_or_output_iterator en todos los casos.

El estándar C++20 requiere que si la llamada subyacente a la función rbegin devuelve un prvalue, el valor de retorno se construye por movimiento desde el objeto temporal materializado. Todas las implementaciones devuelven directamente el prvalue en su lugar. El requisito se corrige mediante la propuesta posterior a C++20 P0849R8 para coincidir con las implementaciones.

Ejemplo

#include <iostream>
#include <ranges>
#include <span>
#include <vector>
int main()
{
    std::vector<int> v = {3, 1, 4};
    auto vi = std::ranges::rbegin(v);
    std::cout << *vi << '\n';
    *vi = 42; // OK
    int a[] = {-5, 10, 15};
    auto ai = std::ranges::rbegin(a);
    std::cout << *ai << '\n';
    *ai = 42; // OK
    // auto x_x = std::ranges::rbegin(std::vector{6, 6, 6});
    // mal formado: el argumento es un valor temporal (ver Notas ↑)
    auto si = std::ranges::rbegin(std::span{a}); // OK
    static_assert(std::ranges::enable_borrowed_range<
        std::remove_cv_t<decltype(std::span{a})>>);
    *si = 42; // OK
}

4
15

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también