std::ranges::cartesian_product_view::end(3)

NAME
std::ranges::cartesian_product_view::end - std::ranges::cartesian_product_view::end

Synopsis
   constexpr iterator<false> end()
       requires ((!__simple_view<First> || ... || !__simple_view<Vs>) (1) (since C++23)
   &&
           __cartesian_product_is_common<First, Vs...>);
   constexpr iterator<true> end() const
       requires __cartesian_product_is_common<const First, const (2) (since C++23)
   Vs...>;
   constexpr std::default_sentinel_t end() const noexcept; (3) (since C++23)
   Returns an iterator or a sentinel representing the end of the
   cartesian_product_view.
   Let bases_ be the underlying tuple of views.
   1,2) Let:
     * __is_const be true for the const-qualified overload, and false otherwise;
     * __is_empty be true if the expression ranges::empty(rng) is true for any rng
       among the underlying ranges except the first one and false otherwise; and
     * __begin_or_first_end(rng) be expression-equivalent to __is_empty ?
       ranges::begin(rng) : __cartesian_common_arg_end(rng) if rng is the first
       underlying range and ranges::begin(rng) otherwise.
   Equivalent to:
 auto check = [](auto& rng) { return __begin_or_first_end(rng); };
 return iterator<__is_const>(__tuple_transform(check, bases_));
   3) Equivalent to: return std::default_sentinel;.

Parameters
   (none)

Return value
   An iterator to the element following the last element, or a sentinel which compares
   equal to the end iterator.

Example
// Run this 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');
 }

Output:
 long

See also
   begin returns an iterator to the beginning
   (C++23) (public member function)
   ranges::end returns a sentinel indicating the end of a range
   (C++20) (customization point object)