View source for cpp/ranges/cartesian product view/iterator/operator arith2

{{title|operator+,-{{small|(ranges::cartesian_product_view::''iterator'')}}}}
{{cpp/ranges/cartesian_product_view/navbar}}

{{dcl begin}}
{{dcl|num=1|since=c++23|
friend constexpr /*iterator*/ operator+( const /*iterator*/& i,
                                         difference_type n )
    requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;
}}
{{dcl|num=2|since=c++23|
friend constexpr /*iterator*/ operator+( difference_type n,
                                         const /*iterator*/& i )
    requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;
}}
{{dcl|num=3|since=c++23|
friend constexpr /*iterator*/ operator-( const /*iterator*/& i,
                                         difference_type n )
    requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;
}}
{{dcl|num=4|since=c++23|
friend constexpr difference_type operator-( const /*iterator*/& i,
                                            const /*iterator*/& j )
    requires
        /*cartesian-is-sized-sentinel*/<Const, iterator_t, First, Vs...>;
}}
{{dcl|num=5|since=c++23|
friend constexpr difference_type operator-( const /*iterator*/& i,
                                            std::default_sentinel_t )
    requires
        /*cartesian-is-sized-sentinel*/<Const, ranges::sentinel_t, First, Vs...>;
}}
{{dcl|num=6|since=c++23|
friend constexpr difference_type operator-( std::default_sentinel_t s,
                                            const /*iterator*/& i )
    requires
        /*cartesian-is-sized-sentinel*/<Const, ranges::sentinel_t, First, Vs...>;
}}
{{dcl end}}

Performs {{rlp|/|iterator}} arithmetic or calculates the distance.

Let {{rlpi|/#Data members|current_}} denote the underlying tuple of iterators and {{rlpi|/#Data members|parent_}} denote the underlying pointer to {{tt|cartesian_product_view}}.

@1@ Equivalent to: {{c|1=return /*iterator*/(i) += n;}}.

@2@ Equivalent to: {{c|return i + n;}}.

@3@ Equivalent to: {{c|1=return /*iterator*/(i) -= n;}}.

@4@ Equivalent to: {{box|{{c/core|return i.}}{{rlpi|helpers#distance_from|distance_from}}{{c/core|(j.current_);}}}}.

@5@ Let {{c|/*end-tuple*/}} be an object of a type that is a specialization of {{lc|std::tuple|tuple}}, such that:
* {{c|std::get<0>(/*end-tuple*/)}} has the same value as {{c|ranges::end(std::get<0>(i.parent_->bases_));}}
* {{c|std::get<N>(/*end-tuple*/)}} has the same value as {{c|ranges::begin(std::get<N>(i.parent_->bases_))}} for every integer {{c|1=1 ≤ N ≤ sizeof...(Vs)}}.
<!---->
Equivalent to: {{box|{{c/core|return i.}}{{rlpi|helpers#distance_from|distance_from}}{{c/core|(/*end-tuple*/);}}}}.

@6@ Equivalent to: {{c|return -(i - s);}}.

{{cpp/hidden friend|{{tt|cartesian_product_view::''iterator''<Const>}}|plural=yes}}

===Parameters===
{{par begin}}
{{par|i, j|the iterators}}
{{par|n|the position relative to current location}}
{{par|s|the sentinel}}
{{par end}}

===Return value===
@1,2@ An incremented iterator.
@3@ A decremented iterator.
@4@ A distance between given iterators.
@5,6@ A distance between given iterator and sentinel.

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc|cpp/ranges/adaptor/iterator/dsc operator arith|cartesian_product_view}}
{{dsc end}}

{{langlinks|de|es|ja|ru|zh}}