std::ranges::views::zip,std::ranges::zip_view(3)

NAME
std::ranges::views::zip,std::ranges::zip_view - std::ranges::views::zip,std::ranges::zip_view

Synopsis
   Defined in header <ranges>
   template< ranges::input_range... Views >
       requires (ranges::view<Views> && ...) && (sizeof...(Views) >
   0) (1) (since C++23)
   class zip_view
       : public ranges::view_interface<zip_view<Views...>>
   namespace views {
       inline constexpr /*unspecified*/ zip = /*unspecified*/; (2) (since C++23)
   }
   Call signature
   template< ranges::viewable_range... Rs >
       requires /* see below */ (since C++23)
   constexpr auto zip( Rs&&... rs );
   1) zip_view is a range adaptor that takes one or more views, and produces a view
   whose ith element is a tuple-like value consisting of the i^th elements of all
   views. The size of produced view is the minimum of sizes of all adapted views.
   2) views::zip is a customization point object.
   When calling with no argument, views::zip() is expression-equivalent to
   auto(views::empty<std::tuple<>>).
   Otherwise, views::zip(rs...) is expression-equivalent to
   ranges::zip_view<views::all_t<decltype((rs))>...>(rs...).
   zip_view always models input_range, and models forward_range, bidirectional_range,
   random_access_range, or sized_range if all adapted view types model the
   corresponding concept.
   zip_view models common_range if
     * sizeof...(Views) is equal to 1, and the only adapted view type models
       common_range, or
     * at least one adapted view type does not model bidirectional_range, and every
       adapted view type models common_range, or
     * every adapted view type models both random_access_range and sized_range.

Member functions
   constructor constructs a zip_view
   (C++23) (public member function)
   begin returns an iterator to the beginning
   (C++23) (public member function)
   end returns an iterator or a sentinel to the end
   (C++23) (public member function)
   size returns the number of elements. Provided only if each underlying
   (C++23) (adapted) range satisfies sized_range.
                 (public member function)
         Inherited from std::ranges::view_interface
   empty returns whether the derived view is empty. Provided if it satisfies
   (C++20) sized_range or forward_range.
                 (public member function of std::ranges::view_interface<D>)
   cbegin returns a constant iterator to the beginning of the range.
   (C++23) (public member function of std::ranges::view_interface<D>)
   cend returns a sentinel for the constant iterator of the range.
   (C++23) (public member function of std::ranges::view_interface<D>)
   operator bool returns whether the derived view is not empty. Provided if
   (C++20) ranges::empty is applicable to it.
                 (public member function of std::ranges::view_interface<D>)
   front returns the first element in the derived view. Provided if it
   (C++20) satisfies forward_range.
                 (public member function of std::ranges::view_interface<D>)
   back returns the last element in the derived view. Provided if it satisfies
   (C++20) bidirectional_range and common_range.
                 (public member function of std::ranges::view_interface<D>)
   operator[] returns the n^th element in the derived view. Provided if it satisfies
   (C++20) random_access_range.
                 (public member function of std::ranges::view_interface<D>)
   Deduction guides
   Nested classes
   iterator the iterator type
   (C++23) (exposition-only member class template*)
   sentinel the sentinel type used when zip_view is not a common_range
   (C++23) (exposition-only member class template*)
   Helper templates
   template< class... Views >
   inline constexpr bool (since C++23)
   enable_borrowed_range<ranges::zip_view<Views...>> =
       (ranges::enable_borrowed_range<Views> && ...);
   This specialization of ranges::enable_borrowed_range makes zip_view satisfy
   borrowed_range when each underlying view satisfies it.

Notes
    Feature-test macro Value Std Feature
                        std::ranges::zip_view,
   __cpp_lib_ranges_zip 202110L (C++23) std::ranges::zip_transform_view,
                        std::ranges::adjacent_view,
                        std::ranges::adjacent_transform_view

Example
// Run this code
 #include <array>
 #include <iostream>
 #include <list>
 #include <ranges>
 #include <string>
 #include <tuple>
 #include <vector>
 void print(auto const rem, auto const& range)
 {
     for (std::cout << rem; auto const& elem : range)
         std::cout << elem << ' ';
     std::cout << '\n';
 }
 int main()
 {
     auto x = std::vector{1, 2, 3, 4};
     auto y = std::list<std::string>{"α", "β", "γ", "δ", "ε"};
     auto z = std::array{'A', 'B', 'C', 'D', 'E', 'F'};
     print("Source views:", "");
     print("x: ", x);
     print("y: ", y);
     print("z: ", z);
     print("\nzip(x,y,z):", "");
     for (std::tuple<int&, std::string&, char&> elem : std::views::zip(x, y, z))
     {
         std::cout << std::get<0>(elem) << ' '
                   << std::get<1>(elem) << ' '
                   << std::get<2>(elem) << '\n';
         std::get<char&>(elem) += ('a' - 'A'); // modifies the element of z
     }
     print("\nAfter modification, z: ", z);
 }

Output:
 Source views:
 x: 1 2 3 4
 y: α β γ δ ε
 z: A B C D E F
 zip(x,y,z):
 1 α A
 2 β B
 3 γ C
 4 δ D
 After modification, z: a b c d E F

See also
   ranges::zip_transform_view a view consisting of tuples of results of application of
   views::zip_transform a transformation function to corresponding elements of
   (C++23) the adapted views
                        (class template) (customization point object)
   ranges::elements_view takes a view consisting of tuple-like values and a number
   views::elements N and produces a view of N^th element of each tuple
   (C++20) (class template) (range adaptor object)