#
zip_transform_view takes an invocable object and any number of views and produces a view whose
2
#
The name views​::​zip_transform denotes a customization point object ([customization.point.object]).
Let F be a subexpression, and let Es.. be a pack of subexpressions.
3
#
[Example 1: vector v1 = {1, 2}; vector v2 = {4, 5, 6}; for (auto i : views::zip_transform(plus(), v1, v2)) { cout << i << ' '; / prints 5 7 } — end example]

25.7.26.2 Class template zip_transform_view [range.zip.transform.view]

🔗
namespace std::ranges { template<move_constructible F, input_range.. Views> requires (view<Views> && ..) && (sizeof.(Views) > 0) && is_object_v<F> && regular_invocable<F&, range_reference_t<Views>.> && can-reference<invoke_result_t<F&, range_reference_t<Views>.> class zip_transform_view : public view_interface<zip_transform_view<F, Views..> { movable-box<F> fun_; / exposition only zip_view<Views..> zip_; / exposition only using InnerView = zip_view<Views..>; / exposition only template<bool Const> using ziperator = iterator_t<maybe-const<Const, InnerView>>; / exposition only template<bool Const> using zentinel = sentinel_t<maybe-const<Const, InnerView>>; / exposition only / [range.zip.transform.iterator], class template zip_transform_view​::​iterator template<bool> class iterator; / exposition only / [range.zip.transform.sentinel], class template zip_transform_view​::​sentinel template<bool> class sentinel; / exposition only public: zip_transform_view() = default; constexpr explicit zip_transform_view(F fun, Views.. views); constexpr auto begin() { return iterator<false>(*this, zip_.begin(); } constexpr auto begin() const requires range<const InnerView> && regular_invocable<const F&, range_reference_t<const Views>.> { return iterator<true>(*this, zip_.begin(); } constexpr auto end() { if constexpr (common_range<InnerView>) { return iterator<false>(*this, zip_.end(); } else { return sentinel<false>(zip_.end(); } } constexpr auto end() const requires range<const InnerView> && regular_invocable<const F&, range_reference_t<const Views>.> { if constexpr (common_range<const InnerView>) { return iterator<true>(*this, zip_.end(); } else { return sentinel<true>(zip_.end(); } } constexpr auto size() requires sized_range<InnerView> { return zip_.size(); } constexpr auto size() const requires sized_range<const InnerView> { return zip_.size(); } }; template<class F, class. Rs> zip_transform_view(F, Rs&&.) -> zip_transform_view<F, views::all_t<Rs>.>; }
🔗
constexpr explicit zip_transform_view(F fun, Views.. views);
1
#
Effects: Initializes fun_ with std​::​move(fun) and zip_ with std​::​move(views)..

25.7.26.3 Class template zip_transform_view​::​iterator [range.zip.transform.iterator]

🔗
namespace std::ranges { template<move_constructible F, input_range.. Views> requires (view<Views> && ..) && (sizeof.(Views) > 0) && is_object_v<F> && regular_invocable<F&, range_reference_t<Views>.> && can-reference<invoke_result_t<F&, range_reference_t<Views>.> template<bool Const> class zip_transform_view<F, Views..>::iterator { using Parent = maybe-const<Const, zip_transform_view>; / exposition only using Base = maybe-const<Const, InnerView>; / exposition only Parent* parent_ = nullptr; / exposition only ziperator<Const> inner_; / exposition only constexpr iterator(Parent& parent, ziperator<Const> inner); / exposition only public: using iterator_category = see below; / not always present using iterator_concept = ziperator<Const>::iterator_concept; using value_type = remove_cvref_t<invoke_result_t<maybe-const<Const, F>&, range_reference_t<maybe-const<Const, Views>>.>; using difference_type = range_difference_t<Base>; iterator() = default; constexpr iterator(iterator<!Const> i) requires Const && convertible_to<ziperator<false>, ziperator<Const>>; constexpr decltype(auto) operator*() const noexcept(see below); constexpr iterator& operator+(); constexpr void operator+(int); constexpr iterator operator+(int) requires forward_range<Base>; constexpr iterator& operator-() requires bidirectional_range<Base>; constexpr iterator operator-(int) requires bidirectional_range<Base>; constexpr iterator& operator+=(difference_type x) requires random_access_range<Base>; constexpr iterator& operator-=(difference_type x) requires random_access_range<Base>; constexpr decltype(auto) operator[](difference_type n) const requires random_access_range<Base>; friend constexpr bool operator=(const iterator& x, const iterator& y) requires equality_comparable<ziperator<Const>>; friend constexpr auto operator<=>(const iterator& x, const iterator& y) requires random_access_range<Base>; friend constexpr iterator operator+(const iterator& i, difference_type n) requires random_access_range<Base>; friend constexpr iterator operator+(difference_type n, const iterator& i) requires random_access_range<Base>; friend constexpr iterator operator-(const iterator& i, difference_type n) requires random_access_range<Base>; friend constexpr difference_type operator-(const iterator& x, const iterator& y) requires sized_sentinel_for<ziperator<Const>, ziperator<Const>>; }; }
1
#
The member typedef-name iterator​::​iterator_category is defined if and only if Base models forward_range.
In that case, iterator​::​iterator_category is defined as follows:
  • (1.1)
    If invoke_result_t<maybe-const<Const, F>&, range_reference_t<maybe-const<Const, Views>>.> is not a reference, iterator_category denotes input_iterator_tag.
  • (1.2)
    Otherwise, let Cs denote the pack of types iterator_traits<iterator_t<maybe-const<Const, Views>>​::​iterator_category...
    • (1.2.1)
      If (derived_from<Cs, random_access_iterator_tag> && ..) is true, iterator_category denotes random_access_iterator_tag.
    • (1.2.2)
      Otherwise, if (derived_from<Cs, bidirectional_iterator_tag> && ..) is true, iterator_category denotes bidirectional_iterator_tag.
    • (1.2.3)
      Otherwise, if (derived_from<Cs, forward_iterator_tag> && ..) is true, iterator_category denotes forward_iterator_tag.
    • (1.2.4)
      Otherwise, iterator_category denotes input_iterator_tag.
🔗
constexpr iterator(Parent& parent, ziperator<Const> inner);
2
#
Effects: Initializes parent_ with addressof(parent) and inner_ with std​::​move(inner).
🔗
constexpr iterator(iterator<!Const> i) requires Const && convertible_to<ziperator<false>, ziperator<Const>>;
3
#
Effects: Initializes parent_ with i.parent_ and inner_ with std​::​move(i.inner_).
🔗
constexpr decltype(auto) operator*() const noexcept(see below);
4
#
Effects: Equivalent to: return apply([&](const auto&. iters) -> decltype(auto) { return invoke(*parent_->fun_, *iters..); }, inner_.current_);
5
#
Remarks: Let Is be the pack 0, 1, …, (sizeof.(Views) - 1).
The exception specification is equivalent to: noexcept(invoke(*parent_->fun_, *std​::​get<Is>(inner_.current_).).
🔗
constexpr iterator& operator+();
6
#
Effects: Equivalent to: ++inner_; return *this;
🔗
constexpr void operator+(int);
7
#
Effects: Equivalent to: ++*this.
🔗
constexpr iterator operator+(int) requires forward_range<Base>;
8
#
Effects: Equivalent to: auto tmp = *this; ++*this; return tmp;
🔗
constexpr iterator& operator-() requires bidirectional_range<Base>;
9
#
Effects: Equivalent to: --inner_; return *this;
🔗
constexpr iterator operator-(int) requires bidirectional_range<Base>;
10
#
Effects: Equivalent to: auto tmp = *this; --*this; return tmp;
🔗
constexpr iterator& operator+=(difference_type x) requires random_access_range<Base>;
11
#
Effects: Equivalent to: inner_ += x; return *this;
🔗
constexpr iterator& operator-=(difference_type x) requires random_access_range<Base>;
12
#
Effects: Equivalent to: inner_ -= x; return *this;
🔗
constexpr decltype(auto) operator[](difference_type n) const requires random_access_range<Base>;
13
#
Effects: Equivalent to: return apply([&]<class. Is>(const Is&. iters) -> decltype(auto) { return invoke(*parent_->fun_, iters[iter_difference_t<Is>(n)].); }, inner_.current_);
🔗
friend constexpr bool operator=(const iterator& x, const iterator& y) requires equality_comparable<ziperator<Const>>; friend constexpr auto operator<=>(const iterator& x, const iterator& y) requires random_access_range<Base>;
14
#
Effects: Equivalent to: return x.inner_ op y.inner_;
🔗
friend constexpr iterator operator+(const iterator& i, difference_type n) requires random_access_range<Base>; friend constexpr iterator operator+(difference_type n, const iterator& i) requires random_access_range<Base>;
16
#
Effects: Equivalent to: return iterator(*i.parent_, i.inner_ + n);
🔗
friend constexpr iterator operator-(const iterator& i, difference_type n) requires random_access_range<Base>;
17
#
Effects: Equivalent to: return iterator(*i.parent_, i.inner_ - n);
🔗
friend constexpr difference_type operator-(const iterator& x, const iterator& y) requires sized_sentinel_for<ziperator<Const>, ziperator<Const>>;
18
#
Effects: Equivalent to: return x.inner_ - y.inner_;

25.7.26.4 Class template zip_transform_view​::​sentinel [range.zip.transform.sentinel]

🔗
namespace std::ranges { template<move_constructible F, input_range.. Views> requires (view<Views> && ..) && (sizeof.(Views) > 0) && is_object_v<F> && regular_invocable<F&, range_reference_t<Views>.> && can-reference<invoke_result_t<F&, range_reference_t<Views>.> template<bool Const> class zip_transform_view<F, Views..>::sentinel { zentinel<Const> inner_; / exposition only constexpr explicit sentinel(zentinel<Const> inner); / exposition only public: sentinel() = default; constexpr sentinel(sentinel<!Const> i) requires Const && convertible_to<zentinel<false>, zentinel<Const>>; template<bool OtherConst> requires sentinel_for<zentinel<Const>, ziperator<OtherConst>> friend constexpr bool operator=(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires sized_sentinel_for<zentinel<Const>, ziperator<OtherConst>> friend constexpr range_difference_t<maybe-const<OtherConst, InnerView>> operator-(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires sized_sentinel_for<zentinel<Const>, ziperator<OtherConst>> friend constexpr range_difference_t<maybe-const<OtherConst, InnerView>> operator-(const sentinel& x, const iterator<OtherConst>& y); }; }
🔗
constexpr explicit sentinel(zentinel<Const> inner);
1
#
Effects: Initializes inner_ with inner.
🔗
constexpr sentinel(sentinel<!Const> i) requires Const && convertible_to<zentinel<false>, zentinel<Const>>;
2
#
Effects: Initializes inner_ with std​::​move(i.inner_).
🔗
template<bool OtherConst> requires sentinel_for<zentinel<Const>, ziperator<OtherConst>> friend constexpr bool operator=(const iterator<OtherConst>& x, const sentinel& y);
3
#
Effects: Equivalent to: return x.inner_ == y.inner_;
🔗
template<bool OtherConst> requires sized_sentinel_for<zentinel<Const>, ziperator<OtherConst>> friend constexpr range_difference_t<maybe-const<OtherConst, InnerView> operator-(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires sized_sentinel_for<zentinel<Const>, ziperator<OtherConst>> friend constexpr range_difference_t<maybe-const<OtherConst, InnerView> operator-(const sentinel& x, const iterator<OtherConst>& y);
4
#
Effects: Equivalent to: return x.inner_ - y.inner_;

Follow Lee on X/Twitter - Father, Husband, Serial builder creating AI, crypto, games & web tools. We are friends :) AI Will Come To Life!

Check out: eBank.nz (Art Generator) | Netwrck.com (AI Tools) | Text-Generator.io (AI API) | BitBank.nz (Crypto AI) | ReadingTime (Kids Reading) | RewordGame | BigMultiplayerChess | WebFiddle | How.nz | Helix AI Assistant