Namespaces
Variants

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

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

Retourne un sentinelle ou un itérateur représentant la fin du take_view . La fin du take_view est soit après le count ème élément de la plage sous-jacente, soit la fin de la plage sous-jacente si celle-ci contient moins de count éléments.

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

La surcharge (1) ne participe pas à la résolution de surcharge si V est une vue simple (c'est-à-dire si V et const V sont des vues avec les mêmes types d'itérateur et de sentinelle).

Table des matières

Paramètres

(aucun)

Valeur de retour

Le résultat dépend des concepts satisfaits par le type de vue sous-jacent potentiellement qualifié const Base , c'est-à-dire V pour ( 1 ) ou const V pour ( 2 ) .

Soit base_ la vue sous-jacente.

Le type de vue sous-jacent
satisfait ...
random_access_range
oui non
sized_range oui ranges:: begin ( base_ ) +
ranges:: range_difference_t < Base_ > ( this - > size ( ) )
std:: default_sentinel
non
1) /*sentinel*/ < false > { ranges:: end ( base_ ) }
2) /*sentinel*/ < true > { ranges:: end ( base_ ) }

Exemple

#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';
}

Sortie :

3 1 4 1
2 7 1 8

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
P2393R1 C++20 les conversions implicites entre les types integer-class signés et non signés peuvent échouer rendues explicites

Voir aussi

retourne un itérateur vers le début
(fonction membre publique)
adaptateur d'itérateur qui suit la distance jusqu'à la fin de la plage
(modèle de classe)
(C++20)
compare un sentinelle avec un itérateur retourné par take_view::begin
(fonction)