std::ranges::views::take, std::ranges::take_view

template< ranges::view V >
class take_view
    : public ranges::view_interface<take_view<V>>

namespace views {
    inline constexpr /* unspecified */ take = /* unspecified */;
}

template< ranges::viewable_range R >
    requires /* see below */
constexpr ranges::view auto
    take( R&& r, ranges::range_difference_t<R> count );

template< class DifferenceType >
constexpr /* range adaptor closure */ take( DifferenceType&& count );

1) Ein Range-Adaptor, der eine View der Elemente aus einer zugrundeliegenden Sequenz darstellt, beginnend am Anfang und endend an einer gegebenen Grenze.

2) views::take ist ein RangeAdaptorObject. Der Ausdruck views::take(e, f) ergibt eine View, die die ersten f Elemente aus e darstellt. Das Ergebnis ist nicht notwendigerweise eine take_view.

views::take(e, f) ist ausdrucksäquivalent zu (wobei T ist std::remove_cvref_t<decltype((e))> und D ist ranges::range_difference_t<decltype((e))>):

• ((void)f, decay-copy(e)), wenn T eine ranges::empty_view ist, außer dass die Auswertungen von e und f unbestimmt sequenziert sind;
• U(ranges::begin(e), ranges::begin(e) + std::min<D>(ranges::distance(e), f)), wenn T eine Spezialisierung von std::span, std::basic_string_view oder ranges::subrange ist, die sowohl random_access_range als auch sized_range modelliert, wobei U ist

• std::span<typename T::element_type>, wenn T eine Spezialisierung von std::span ist;
• T, wenn T eine Spezialisierung von std::basic_string_view ist;
• ranges::subrange<ranges::iterator_t<T>>, wenn T eine Spezialisierung von ranges::subrange ist;

• ranges::iota_view(*ranges::begin(e),
*(ranges::begin(e) + std::min<D>(ranges::distance(e), f))), wenn T eine Spezialisierung von ranges::iota_view ist, die sowohl random_access_range als auch sized_range modelliert;

andernfalls, wenn T eine Spezialisierung von ranges::repeat_view ist: views::repeat(*e.value_, std::min<D>(ranges::distance(e), f)), wenn T sized_range modelliert; in diesem Fall wird e nur einmal ausgewertet; views::repeat(*e.value_, static_cast<D>(e)) andernfalls;

(seit C++23)

• andernfalls, take_view(e, f).

In allen Fällen muss decltype((f)) std::convertible_to<D> modellieren.

#include <algorithm>
#include <iostream>
#include <ranges>
int main()
{
    namespace views = std::views;
    auto print = [](char x){ std::cout << x; };
    for (const char nums[]{'1', '2', '3'};
         int n : views::iota(0, 5))
    {
        std::cout << "take(" << n << "): ";
        // safely takes only upto min(n, nums.size()) elements:
        std::ranges::for_each(nums | views::take(n), print);
        std::cout << '\n';
    }
}

take(0): 
take(1): 1
take(2): 12
take(3): 123
take(4): 123