From cppreference.com
Defined in header
Call signature
template<std::bidirectional_iteratorI,std::sentinel_for<I>S,/*indirectly-binary-right-foldable*/<std::iter_value_t<I>,I>F>requiresstd::constructible_from<std::iter_value_t<I>,std::iter_reference_t<I>>constexprautofold_right_last(Ifirst,Slast,Ff); (1) (since C++23)template<ranges::bidirectional_rangeR,/*indirectly-binary-right-foldable*/<ranges::range_value_t<R>,ranges::iterator_t<R>>F>requiresstd::constructible_from<ranges::range_value_t<R>,ranges::range_reference_t<R>>constexprautofold_right_last(R&&r,Ff); (2) (since C++23)For the definition of /*indirectly-binary-right-foldable*/, see
.
Right-
the elements of the source range, that is, returns the result of evaluation of the chain expression:
f(x1, f(x2, ...f(xn-1, xn))), where x1, x2, ..., xn are elements of the source range.
1) The source range is [first, last).
2) The source range is r.
The function-like entities described on this page are
(informally known as niebloids), that is:
Explicit template argument lists cannot be specified when calling any of them.
None of them are visible to
.
When any of them are found by
as the name to the left of the function-call operator,
is inhibited.
Parameters
first, last - the iterator-sentinel pair defining the source
r - the source range f - the binary function object Return value
An
object containing the right-fold result, or does not contain a value if the source range is empty.
Notes
The following table compares all constrained folding algorithms. U below is the fold result type, it is the decayed type of F's result type.
Fold function template Starts from Initial value Return type ranges::fold_leftleftinitUranges::fold_left_firstleftfirst elementstd::optional<U>ranges::fold_rightrightinitUranges::fold_right_lastrightlast elementstd::optional<U>ranges::fold_left_with_iterleftinit(1) ranges::in_value_result<I,U>
(2) ranges::in_value_result<BR,U>,
where BR is ranges::borrowed_iterator_t<R>
ranges::fold_left_first_with_iterleftfirst element(1) ranges::in_value_result<I,std::optional<U>>
(2) ranges::in_value_result<BR,std::optional<U>>
where BR is ranges::borrowed_iterator_t<R>
macroValueStdFeature
(C++23)std::ranges
Possible implementations
structfold_right_last_fn{template<std::bidirectional_iteratorI,std::sentinel_for<I>S,/*indirectly-binary-right-foldable*/<std::iter_value_t<I>,I>F>requiresstd::constructible_from<std::iter_value_t<I>,std::iter_reference_t<I>>constexprautooperator()(Ifirst,Slast,Ff)const{usingU=decltype(ranges::fold_right(first,last,std::iter_value_t<I>(*first),f));if(first==last)returnstd::optional<U>();Itail=ranges::prev(ranges::next(first,std::move(last)));returnstd::optional<U>(std::in_place,ranges::fold_right(std::move(first),tail,std::iter_value_t<I>(*tail),std::move(f)));}template<ranges::bidirectional_rangeR,/*indirectly_binary_right_foldable*/<ranges::range_value_t<R>,ranges::iterator_t<R>>F>requiresstd::constructible_from<ranges::range_value_t<R>,ranges::range_reference_t<R>>constexprautooperator()(R&&r,Ff)const{return(*this)(ranges::begin(r),ranges::next(ranges::begin(r),ranges::end(r)),std::ref(f));}};inlineconstexprfold_right_last_fnfold_right_last;Example
Run this code
#include<algorithm>#include<functional>#include<iostream>#include<ranges>#include<utility>#include<vector>intmain(){autov={1,2,3,4,5,6,7,8};std::vector<std::string>vs{"A","B","C","D"};autor1=std::ranges::fold_right_last(v.begin(),v.end(),std::plus<>());// (1)std::cout<<"*r1: "<<*r1<<'\n';autor2=std::ranges::fold_right_last(vs,std::plus<>());// (2)std::cout<<"*r2: "<<*r2<<'\n';// Use a program defined function object (lambda-expression):autor3=std::ranges::fold_right_last(v,[](intx,inty){returnx+y+99;});std::cout<<"*r3: "<<*r3<<'\n';// Get the product of the std::pair::second of all pairs in the vector:std::vector<std::pair<char,float>>data{{'A',3.f},{'B',3.5f},{'C',4.f}};autor4=std::ranges::fold_right_last(data|std::ranges::views::values,std::multiplies<>());std::cout<<"*r4: "<<*r4<<'\n';}Output:
*r1: 36 *r2: ABCD *r3: 729 *r4: 42 References
C++23 standard (ISO/IEC 14882:2024):
27.6.18 Fold [alg.fold]
See also
(C++23)
right-folds a range of elements
(algorithm function object)
(C++23)
left-folds a range of elements
(algorithm function object)
(C++23)
left-folds a range of elements using the first element as an initial value
(algorithm function object)
(C++23)
left-folds a range of elements, and returns a
(iterator, value)
(algorithm function object)
ranges::fold_left_first_with_iter
(C++23)
left-folds a range of elements using the first element as an initial value, and returns a
(iterator,
)
(algorithm function object)
sums up or folds a range of elements
(function template)
(C++17)
similar to
, except out of order
(function template)