std::ranges::zip_view::iterator(3)

NAME
std::ranges::zip_view::iterator - std::ranges::zip_view::iterator

Synopsis
   template< bool Const > (1) (exposition
   class /*iterator*/; only*)
   Helper concepts
   template< bool C, class... Views >
   concept /*all-forward*/ = (2) (exposition
                        only*)
       (ranges::forward_range<std::conditional_t<C, const Views,
   Views>> && ...);
   template< bool C, class... Views >
   concept /*all-bidirectional*/ = (3) (exposition
                        only*)
       (ranges::bidirectional_range<std::conditional_t<C, const Views,
   Views>> && ...);
   template< bool C, class... Views >
   concept /*all-random-access*/ = (4) (exposition
                        only*)
       (ranges::random_access_range<std::conditional_t<C, const Views,
   Views>> && ...);
   The iterator type of a possibly const-qualified zip_view, returned by
   zip_view::begin and in certain cases by zip_view::end.
   The type /*iterator*/<true> or /*iterator*/<false> treats the underlying views as
   const-qualified or non-const-qualified respectively.

Member types
   Member type Definition
                       * std::random_access_iterator_tag if
                        /*all-random-access*/<Const, Views...> is true, otherwise
                       * std::bidirectional_iterator_tag if
   iterator_concept /*all-bidirectional*/<Const, Views...> is true, otherwise
                       * std::forward_iterator_tag if /*all-forward*/<Const, Views...>
                        is true, otherwise
                       * std::input_iterator_tag
                       * std::input_iterator_tag if /*all-forward*/<Const, Views...> is
   iterator_category true,
                       * not defined otherwise
   value_type * std::tuple<ranges::range_value_t<Views>...> if Const is false,
                       * std::tuple<ranges::range_value_t<const Views>...> otherwise.
                       * std::common_type_t<ranges::range_difference_t<Views>...> if
   difference_type Const is false,
                       * std::common_type_t<ranges::range_difference_t<const Views>...>
                        otherwise.
   Data members
   Member object Definition
                      A tuple of underlying iterators of type
                      std::tuple<ranges::iterator_t<Views>...> or
   current_ (private) std::tuple<ranges::iterator_t<const Views>...> when Const is
                      false or true respectively.
                      (exposition-only member object*)

Member functions
   constructor constructs an iterator
   (C++23) (public member function)
   operator* obtains a tuple-like value that consists of underlying pointed-to
   (C++23) elements
                   (public member function)
   operator[] obtains a tuple-like value that consists of underlying elements at
   (C++23) given offset
                   (public member function)
   operator++
   operator++(int)
   operator-- advances or decrements the underlying iterators
   operator--(int) (public member function)
   operator+=
   operator-=
   (C++23)

Non-member functions
   operator==
   operator<
   operator> compares the underlying iterators
   operator<= (function)
   operator>=
   operator<=>
   (C++23)
   operator+ performs iterator arithmetic on underlying iterators
   operator- (function)
   (C++23)
   iter_move obtains a tuple-like value that denotes underlying pointed-to elements
   (C++23) to be moved
               (function)
   iter_swap swaps underlying pointed-to elements
   (C++23) (function)