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

1) Un adaptateur de gamme qui représente une view des éléments d'une séquence sous-jacente, commençant au début et se terminant à une limite donnée.

2) views::take is a RangeAdaptorObject . The expression vues :: take ( e, f ) results in a view that represents the first f elements from e . The result is not necessarily a take_view .

views :: take ( e, f ) est expression-équivalent à (où T est std:: remove_cvref_t < decltype ( ( e ) ) > et D est ranges:: range_difference_t < decltype ( ( e ) ) > ) :

• ( ( void ) f, decay-copy ( e ) ) , si T est un ranges:: empty_view , sauf que les évaluations de e et f sont séquencées de manière indéterminée ;
• U ( ranges:: begin ( e ) , ranges:: begin ( e ) + std:: min < D > ( ranges:: distance ( e ) , f ) ) , si T est une spécialisation de std:: span , std::basic_string_view , ou ranges:: subrange qui modélise à la fois random_access_range et sized_range , où U est

• std:: span < typename T :: element_type > , si T est une spécialisation de std:: span ;
• T , si T est une spécialisation de std::basic_string_view ;
• ranges:: subrange < ranges:: iterator_t < T >> , si T est une spécialisation de ranges:: subrange ;

• ranges:: iota_view ( * ranges:: begin ( e ) ,
  * ( ranges:: begin ( e ) + std:: min < D > ( ranges:: distance ( e ) , f ) ) ) , si T est une spécialisation de ranges:: iota_view qui modélise à la fois random_access_range et sized_range ;

sinon, si T est une spécialisation de ranges::repeat_view : views:: repeat ( * e. value_ , std:: min < D > ( ranges:: distance ( e ) , f ) ) , si T modélise sized_range ; dans ce cas e n'est évalué qu'une seule fois ; views:: repeat ( * e. value_ , static_cast < D > ( e ) ) sinon ;

(depuis C++23)

• sinon, take_view ( e, f ) .

In all cases, decltype ( ( f ) ) must model std:: convertible_to < D > .

#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 << "): ";
        // prend uniquement jusqu'à min(n, nums.size()) éléments de manière sécurisée :
        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