Namespaces
Variants

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

Depuis fr.cppreference.net
 
 
Bibliothèque de plages
Adaptateurs de plages
 
 
constexpr auto end() requires (!/*simple-view*/<V>);
(1) (depuis C++20)
constexpr auto end() const requires ranges::range<const V>;
(2) (depuis C++20)

Renvoie un sentinel ou un itérateur représentant la fin de la take_view. La fin de la take_view est soit un élément après le count-iè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) Renvoie un take_view::/*sentinel*/<false>, un std::default_sentinel_t, ou un ranges::iterator_t<V>.
2) Renvoie 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 simple vue (c'est-à-dire si V et const V sont des vues avec les mêmes types d'itérateur et de sentinel).

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)