Left-folds the elements of given range, that is, returns the result of evaluation of the chain expression:
f(f(f(f(init, x1), x2), ...), xn), wherex1,x2, ...,xn are elements of the range.

Informally,ranges::fold_left behaves likestd::accumulate's overload that accepts a binary predicate.

The behavior is undefined if[first, last) is not a valid range.

The function-like entities described on this page arealgorithm function objects (informally known asniebloids), that is:

• Explicit template argument lists cannot be specified when calling any of them.
• None of them are visible toargument-dependent lookup.
• When any of them are found bynormal unqualified lookup as the name to the left of the function-call operator,argument-dependent lookup is inhibited.

[edit]Parameters

[edit]Return value

An object of typeU that contains the result of left-fold of the given range overf, whereU is equivalent tostd::decay_t<std::invoke_result_t<F&, T,std::iter_reference_t<I>>>.

If the range is empty,U(std::move(init)) is returned.

[edit]Possible implementations

struct fold_left_fn{template<std::input_iterator I,std::sentinel_for<I> S,class T=std::iter_value_t<I>,/* indirectly-binary-left-foldable */<T, I> F>constexprauto operator()(I first, S last, T init, F f)const{using U=std::decay_t<std::invoke_result_t<F&, T,std::iter_reference_t<I>>>;if(first== last)return U(std::move(init));        U accum=std::invoke(f, std::move(init),*first);for(++first; first!= last;++first)            accum=std::invoke(f, std::move(accum),*first);return std::move(accum);} template<ranges::input_range R,class T=ranges::range_value_t<R>,/* indirectly-binary-left-foldable */<T,ranges::iterator_t<R>> F>constexprauto operator()(R&& r, T init, F f)const{return(*this)(ranges::begin(r),ranges::end(r), std::move(init),std::ref(f));}}; inlineconstexpr fold_left_fn fold_left;

[edit]Complexity

Exactlyranges::distance(first, last) applications of the function objectf.

[edit]Notes

The following table compares all constrained folding algorithms:

[edit]Example

#include <algorithm>#include <complex>#include <functional>#include <iostream>#include <ranges>#include <string>#include <utility>#include <vector> int main(){namespace ranges= std::ranges; std::vector v{1,2,3,4,5,6,7,8}; int sum= ranges::fold_left(v.begin(), v.end(),0,std::plus<int>());// (1)std::cout<<"sum: "<< sum<<'\n'; int mul= ranges::fold_left(v,1,std::multiplies<int>());// (2)std::cout<<"mul: "<< mul<<'\n'; // get the product of the std::pair::second of all pairs in the vector:std::vector<std::pair<char,float>> data{{'A',2.f},{'B',3.f},{'C',3.5f}};float sec= ranges::fold_left(        data| ranges::views::values,2.0f,std::multiplies<>());std::cout<<"sec: "<< sec<<'\n'; // use a program defined function object (lambda-expression):std::string str= ranges::fold_left(        v,"A",[](std::string s,int x){return s+':'+std::to_string(x);});std::cout<<"str: "<< str<<'\n'; using CD=std::complex<double>;std::vector<CD> nums{{1,1},{2,0},{3,0}};#ifdef __cpp_lib_algorithm_default_value_typeauto res= ranges::fold_left(nums,{7,0},std::multiplies{});// (2)#elseauto res= ranges::fold_left(nums, CD{7,0},std::multiplies{});// (2)#endifstd::cout<<"res: "<< res<<'\n';}

sum: 36mul: 40320sec: 42str: A:1:2:3:4:5:6:7:8res: (42,42)

[edit]References

[edit]See also

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文