std::ranges::views::zip_transform, std::ranges::zip_transform_view
Defined in header <ranges> |
||
---|---|---|
template< std::copy_constructible F, ranges::input_range... Views > requires (ranges::view<Views> && ...) && (sizeof...(Views) > 0) && std::is_object_v<F> && std::regular_invocable< F&, ranges::range_reference_t<Views>...> && /*can-reference*/<std::invoke_result_t< F&, ranges::range_reference_t<Views>...>> class zip_transform_view : public ranges::view_interface<zip_transform_view<F, Views...>> |
(1) | (since C++23) |
namespace views { inline constexpr /*unspecified*/ zip_transform = /*unspecified*/; } |
(2) | (since C++23) |
Call signature | ||
template< class F, ranges::viewable_range... Rs > requires /* see below */ constexpr auto zip_transform( F&& f, Rs&&... rs ); |
(since C++23) |
zip_transform_view
is a range adaptor that takes an invocable object and one or more
view
s, and produces a
view
whose
i
th element is the result of applying the invocable object to the
i
th elements of all views.
A type
T
models the exposition-only concept
can-reference
if and only if
T&
is a valid type.
views::zip_transform
is a customization point object.
When calling with one argument f
, let FD
be std::decay_t<decltype(f)>
, if:
-
FD
modelscopy_constructible
, -
FD&
modelsregular_invocable
, and -
std::invoke_result_t<FD&>
is an object type,
then views::zip_transform(f)
is expression-equivalent to ((void)f, auto(views::empty<std::decay_t<std::invoke_result_t<FD&>>>))
. Otherwise, the call to views::zip_transform
is ill-formed. When calling with more than one arguments f
and rs...
, views::zip_transform(f, rs...)
is.
ranges::zip_transform_view(f, rs...)
.
zip_transform_view
models the concepts random_access_range
, bidirectional_range
, forward_range
, input_range
, common_range
, and sized_range
when the underlying ranges::zip_view<Views...>
models respective concepts.
Customization point objects
The name views::zip_transform
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_transform_fn
.
All instances of __zip_transform_fn
are equal. The effects of invoking different instances of type __zip_transform_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_transform
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_transform
above, __zip_transform_fn
models
.
-
std::invocable<__zip_transform_fn, Args...>
, -
std::invocable<const __zip_transform_fn, Args...>
, -
std::invocable<__zip_transform_fn&, Args...>
, and -
std::invocable<const __zip_transform_fn&, Args...>
.
Otherwise, no function call operator of __zip_transform_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_transform_view
hold two non-static data members:
- an underlying view object of type
ranges::zip_view<Views...>
(shown here aszip_
for exposition only), and - a wrapped invocable object of type
copyable-box<F>
(shown here asfun_
for exposition only).
Member functions
(C++23)
|
constructs a zip_transform_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 the underlying 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 <ranges> #include <vector> #include <iostream> void print(auto const rem, auto const& r) { for (std::cout << rem; auto const& e : r) std::cout << e << ' '; std::cout << '\n'; } int main() { auto v1 = std::vector<float>{1, 2, 3}; auto v2 = std::list<short>{1, 2, 3, 4}; auto v3 = std::to_array({1, 2, 3, 4, 5}); auto add = [](auto a, auto b, auto c) { return a + b + c; }; auto sum = std::views::zip_transform(add, v1, v2, v3); print("v1: ", v1); print("v2: ", v2); print("v3: ", v3); print("sum: ", sum); }
Output:
v1: 1 2 3 v2: 1 2 3 4 v3: 1 2 3 4 5 sum: 3 6 9
See also
(C++23)
|
a view consisting of tuples of references to corresponding elements of the adapted views (class template) (customization point object) |
(C++20)
|
a view of a sequence that applies a transformation function to each element (class template) (range adaptor object) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/ranges/zip_transform_view