Namespaces
Variants

    std::ranges::cartesian_product_view<First, Vs...>::end

    De fr.cppreference.net
     
    C++
     
    Ranges library
    Adaptateurs de plage
     
    std::ranges::cartesian_product_view
    Fonctions membres
    Guides de déduction
    Itérateur
    Fonctions membres
    Fonctions non membres
     
    constexpr iterator<false> end()
    requires ((!/*simple-view*/<First> || ... || !/*simple-view*/<Vs>) &&
        /*cartesian-product-is-common*/<First, Vs...>);
    		(1) (depuis C++23) 
    constexpr iterator<true> end() const
    requires /*cartesian-product-is-common*/<const First, const Vs...>;
    		(2) (depuis C++23) 
    constexpr std::default_sentinel_t end() const noexcept;
    		(3) (depuis C++23)

    Retourne un iterator ou une sentinelle représentant la fin de la cartesian_product_view.

    Soit bases_ le tuple sous-jacent de vues.

    1,2) Équivalent à
    auto check = [](auto& rng) { return __begin_or_first_end(rng); };
    return iterator<__is_const>(/*tuple-transform*/(check, bases_));    ,
    où :
    • __is_const est true pour la qualifiée const surcharge, et false sinon.
    • __is_empty est true si l'expression ranges::empty(rng) est true pour toute rng parmi les plages sous-jacentes sauf la première et false sinon.
    • __begin_or_first_end(rng) est expression-équivalent à __is_empty ? ranges::begin(rng) : /*cartesian-common-arg-end*/(rng) si rng est la première plage sous-jacente et ranges::begin(rng) sinon.
    3) Équivalent à : return std::default_sentinel;.

    Paramètres

    (aucun)

    Valeur de retour

    Un itérateur vers l'élément suivant le dernier élément, ou un sentinelle qui compare égal à l'itérateur de fin.

    Exemple

    Exécuter ce code 
    #include <array>
#include <format>
#include <iostream>
#include <ranges>
#include <string_view>
#include <tuple>
using namespace std::literals;
int main()
{
    constexpr auto a = std::array{ "bool"sv, "goto"sv, "extern"sv, "long"sv }; /*
                                       ^         ^           ^         ^        */
    constexpr auto v = std::ranges::cartesian_product_view(a[0], a[1], a[2], a[3]);
    constexpr std::tuple<char const&,
                         char const&,
                         char const&,
                         char const&> last{*(v.end() - 1)};
    std::cout << std::format("{}{}{}{}{}",
                             std::get<0>(last),
                             std::get<1>(last),
                             std::get<2>(last),
                             std::get<3>(last), '\n');
}

    Sortie : 

    long

    Voir aussi

    		retourne un itérateur vers le début
    (fonction membre publique)
    (C++20)
    		retourne un sentinelle indiquant la fin d'un intervalle
    (objet de point de personnalisation)