Namespaces
Variants

std::ranges::take_view<V>:: end

From cppreference.net
Ranges library
Range adaptors
constexpr auto end ( ) requires ( ! /*simple-view*/ < V > ) ;
(1) (desde C++20)
constexpr auto end ( ) const requires ranges:: range < const V > ;
(2) (desde C++20)

Retorna un centinela o un iterador que representa el final del take_view . El final del take_view es ya sea uno después del elemento número count th en el rango subyacente, o el final del rango subyacente si este último tiene menos de count elementos.

1) Retorna un take_view :: /*sentinel*/ < false > , un std:: default_sentinel_t , o un ranges:: iterator_t < V > .
2) Retorna un take_view :: /*sentinel*/ < true > , un std:: default_sentinel_t , o un ranges:: iterator_t < const V > .

La sobrecarga (1) no participa en la resolución de sobrecarga si V es una vista simple (es decir, si V y const V son vistas con los mismos tipos de iterador y centinela).

Contenidos

Parámetros

(ninguno)

Valor de retorno

El resultado depende de los conceptos satisfechos por el tipo de vista subyacente posiblemente calificado como const Base , es decir V para ( 1 ) o const V para ( 2 ) .

Sea base_ la vista subyacente.

El tipo de vista subyacente
satisface ...
random_access_range
no
sized_range ranges:: begin ( base_ ) +
ranges:: range_difference_t < Base_ > ( this - > size ( ) )
std:: default_sentinel
no
1) /*sentinel*/ < false > { ranges:: end ( base_ ) }
2) /*sentinel*/ < true > { ranges:: end ( base_ ) }

Ejemplo

#include <iostream>
#include <iterator>
#include <list>
#include <ranges>
#include <type_traits>
namespace ranges = std::ranges;
namespace views = std::views;
int main()
{
    const auto list1 = {3, 1, 4, 1, 5};
    const auto seq1{list1 | views::take(4)};
    static_assert(ranges::sized_range<decltype(seq1)> and
                  ranges::random_access_range<decltype(seq1)> and
                  std::is_same_v<decltype(seq1.end()), decltype(list1.end())>);
    for (auto it = seq1.begin(); it != seq1.end(); ++it)
        std::cout << *it << ' ';
    std::cout << '\n';
    std::list list2{2, 7, 1, 8, 2};
    const auto seq2{list2 | views::take(4)};
    static_assert(ranges::sized_range<decltype(seq2)> and
                  not ranges::random_access_range<decltype(seq2)> and
                  std::is_same_v<decltype(seq2.end()), std::default_sentinel_t>);
    for (auto it = seq2.begin(); it != std::default_sentinel; ++it)
        std::cout << *it << ' ';
    std::cout << '\n';
}

Salida:

3 1 4 1
2 7 1 8

Informes de defectos

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

DR Aplicado a Comportamiento publicado Comportamiento correcto
P2393R1 C++20 las conversiones implícitas entre tipos integer-class con signo y sin signo podrían fallar hecho explícito

Véase también

devuelve un iterador al inicio
(función miembro pública)
adaptador de iterador que rastrea la distancia hasta el final del rango
(plantilla de clase)
(C++20)
compara un centinela con un iterador devuelto por take_view::begin
(función)