std::ranges::views::zip, std::ranges::zip_view
Defined in header <ranges> |
||
---|---|---|
template< ranges::input_range... Views > requires (ranges::view<Views> && ...) && (sizeof...(Views) > 0) class zip_view : public ranges::view_interface<zip_view<Views...>> |
(1) | (since C++23) |
namespace views { inline constexpr /*unspecified*/ zip = /*unspecified*/; } |
(2) | (since C++23) |
Call signature | ||
template< ranges::viewable_range... Rs > requires /* see below */ constexpr auto zip( Rs&&... rs ); |
(since C++23) |
zip_view
is a range adaptor that takes one or more
view
s, and produces a
view
whose
i
th 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.
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.
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 modelscommon_range
, or - at least one adapted view type does not model
bidirectional_range
, and every adapted view type modelscommon_range
, or - every adapted view type models both
random_access_range
andsized_range
.
Customization point objects
The name views::zip
denotes a customization point object, which is a const function object of a literal semiregular
class type. For exposition purposes, the cv-unqualified version of its type is denoted as __zip_fn
.
All instances of __zip_fn
are equal. The effects of invoking different instances of type __zip_fn
on the same arguments are equivalent, regardless of whether the expression denoting the instance is an lvalue or rvalue, and is const-qualified or not (however, a volatile-qualified instance is not required to be invocable). Thus, views::zip
can be copied freely and its copies can be used interchangeably.
Given a set of types Args...
, if std::declval<Args>()...
meet the requirements for arguments to views::zip
above, __zip_fn
models
.
-
std::invocable<__zip_fn, Args...>
, -
std::invocable<const __zip_fn, Args...>
, -
std::invocable<__zip_fn&, Args...>
, and -
std::invocable<const __zip_fn&, Args...>
.
Otherwise, no function call operator of __zip_fn
participates in overload resolution.
Expression-equivalent
Expression e
is expression-equivalent to expression f
, if.
-
e
andf
have the same effects, and - either both are constant subexpressions or else neither is a constant subexpression, and
- either both are potentially-throwing or else neither is potentially-throwing (i.e.
noexcept(e) == noexcept(f)
).
Data members
Typical implementations of zip_view
hold only one non-static data member: a std::tuple<Views...>
holding all adapted view objects.
For the purpose of exposition, the view objects in that std::tuple
are shown as vs_...
here.
Member functions
(C++23)
|
constructs a zip_view (public member function) |
(C++23)
|
returns an iterator to the beginning (public member function) |
(C++23)
|
returns an iterator or a sentinel to the end (public member function) |
(C++23)
|
returns the number of elements. Provided only if each underlying (adapted) range satisfies sized_range . (public member function) |
Inherited from |
|
(C++20)
|
Returns whether the derived view is empty. Provided if it satisfies forward_range . (public member function of std::ranges::view_interface<D> ) |
(C++20)
|
Returns whether the derived view is not empty. Provided if ranges::empty is applicable to it. (public member function of std::ranges::view_interface<D> ) |
(C++20)
|
Returns the first element in the derived view. Provided if it satisfies forward_range . (public member function of std::ranges::view_interface<D> ) |
(C++20)
|
Returns the last element in the derived view. Provided if it satisfies bidirectional_range and common_range . (public member function of std::ranges::view_interface<D> ) |
(C++20)
|
Returns the nth element in the derived view. Provided if it satisfies random_access_range . (public member function of std::ranges::view_interface<D> ) |
Deduction guides
Nested classes
(C++23)
|
the iterator type (exposition-only member class template) |
(C++23)
|
the sentinel type used when zip_view is not a common_range (exposition-only member class template) |
Notes
Feature testing macro: __cpp_lib_ranges_zip
.
Example
#include <list> #include <array> #include <tuple> #include <ranges> #include <vector> #include <string> #include <iostream> 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
(C++23)
|
a view consisting of tuples of results of application of a transformation function to corresponding elements of the adapted views (class template) (customization point object) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/ranges/zip_view