Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      std::ranges::fold_left_with_iter,std::ranges::fold_left_with_iter_result

      From cppreference.com
      <cpp‎ |algorithm‎ |ranges
       
       
      Algorithm library
      Constrained algorithms and algorithms on ranges(C++20)
      Constrained algorithms, e.g.ranges::copy,ranges::sort, ...
      Execution policies(C++17)
      Sorting and related operations
      Partitioning operations
      Sorting operations
      Binary search operations
      (on partitioned ranges)
      Set operations (on sorted ranges)
      Merge operations (on sorted ranges)
      Heap operations
      Minimum/maximum operations
      (C++11)
      (C++17)
      Lexicographical comparison operations
      Permutation operations
      C library
      Numeric operations
      Operations on uninitialized memory
       
      Constrained algorithms
      All names in this menu belong to namespacestd::ranges
      Non-modifying sequence operations
      Modifying sequence operations
      Partitioning operations
      Sorting operations
      Binary search operations (on sorted ranges)
             
             
      Set operations (on sorted ranges)
      Heap operations
      Minimum/maximum operations
      Permutation operations
      Fold operations
      (C++23)
      (C++23)  
      (C++23)
      (C++23)  
      fold_left_with_iter
      (C++23)
      Operations on uninitialized storage
      Return types
       
      Defined in header<algorithm>
      Call signature
      (1)
      template<std::input_iterator I,std::sentinel_for<I> S,class T,

               /* indirectly-binary-left-foldable */<T, I> F>
      constexpr/* see description */

          fold_left_with_iter( I first, S last, T init, F f);
      		(since C++23)
      (until C++26)
      template<std::input_iterator I,std::sentinel_for<I> S,

               class T=std::iter_value_t<I>,
               /* indirectly-binary-left-foldable */<T, I> F>
      constexpr/* see description */

          fold_left_with_iter( I first, S last, T init, F f);
      		(since C++26)
      (2)
      template<ranges::input_range R,class T,

               /* indirectly-binary-left-foldable */
                   <T,ranges::iterator_t<R>> F>
      constexpr/* see description */

          fold_left_with_iter( R&& r, T init, F f);
      		(since C++23)
      (until C++26)
      template<ranges::input_range R,class T=ranges::range_value_t<R>,

               /* indirectly-binary-left-foldable */
                   <T,ranges::iterator_t<R>> F>
      constexpr/* see description */

          fold_left_with_iter( R&& r, T init, F f);
      		(since C++26)
      Helper concepts
      template<class F,class T,class I>
      concept/* indirectly-binary-left-foldable */=/* see description */;
      		 (3)(exposition only*)
      Helper class template
      template<class I,class T>
      using fold_left_with_iter_result=ranges::in_value_result<I, T>;
      		 (4)(since C++23)

      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_with_iter behaves likestd::accumulate's overload that accepts a binary predicate.

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

      1) The range is[first, last).
      2) Same as(1), except that usesr as the range, as if by usingranges::begin(r) asfirst andranges::end(r) aslast.
      3) Equivalent to:
      Helper concepts
      template<class F,class T,class I,class U>

      concept/*indirectly-binary-left-foldable-impl*/=
         std::movable<T>&&
         std::movable<U>&&
         std::convertible_to<T, U>&&
         std::invocable<F&, U,std::iter_reference_t<I>>&&
         std::assignable_from<U&,

             std::invoke_result_t<F&, U,std::iter_reference_t<I>>>;
      		 (3A)(exposition only*)
      template<class F,class T,class I>

      concept/*indirectly-binary-left-foldable*/=
         std::copy_constructible<F>&&
         std::indirectly_readable<I>&&
         std::invocable<F&, T,std::iter_reference_t<I>>&&
         std::convertible_to<std::invoke_result_t<F&, T,std::iter_reference_t<I>>,
             std::decay_t<std::invoke_result_t<F&, T,std::iter_reference_t<I>>>>&&
         /*indirectly-binary-left-foldable-impl*/<F, T, I,

             std::decay_t<std::invoke_result_t<F&, T,std::iter_reference_t<I>>>>;
      		 (3B)(exposition only*)
      4) The return type alias. See "Return value" section for details.

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

      Contents

      [edit]Parameters

      first, last - the iterator-sentinel pair defining therange of elements to fold
      r - the range of elements to fold
      init - the initial value of the fold
      f - the binary function object

      [edit]Return value

      LetU bestd::decay_t<std::invoke_result_t<F&, T,std::iter_reference_t<I>>>.

      1) An object of typeranges::fold_left_with_iter_result<I, U>.
      • The memberranges::in_value_result::in holds an iterator to the end of the range.
      • The memberranges::in_value_result::value holds the result of the left-fold of given range overf.
      If the range is empty, the return value is obtained via the expression equivalent toreturn{std::move(first), U(std::move(init))};.
      2) Same as(1) except that the return type isranges::fold_left_with_iter_result<ranges::borrowed_iterator_t<R>, U>.

      [edit]Possible implementations

      class fold_left_with_iter_fn{template<class O,class I,class S,class T,class F>constexprauto impl(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>>>;using Ret= ranges::fold_left_with_iter_result<O, U>;if(first== last)return Ret{std::move(first), 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 Ret{std::move(first), std::move(accum)};}public: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{return impl<I>(std::move(first), std::move(last), std::move(init),std::ref(f));} 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 impl<ranges::borrowed_iterator_t<R>>(ranges::begin(r),ranges::end(r), std::move(init),std::ref(f));}}; inlineconstexpr fold_left_with_iter_fn fold_left_with_iter;

      [edit]Complexity

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

      [edit]Notes

      The following table compares all constrained folding algorithms:

      Fold function templateStarts fromInitial valueReturn type
      ranges::fold_leftleftinitU
      ranges::fold_left_firstleftfirst elementstd::optional<U>
      ranges::fold_rightrightinitU
      ranges::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>,

      whereBR isranges::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>>

      whereBR isranges::borrowed_iterator_t<R>

      Feature-test macroValueStdFeature
      __cpp_lib_ranges_fold202207L(C++23)std::rangesfold algorithms
      __cpp_lib_algorithm_default_value_type202403L(C++26)List-initialization for algorithms(1,2)

      [edit]Example

      Run this code
      #include <algorithm>#include <cassert>#include <complex>#include <functional>#include <ranges>#include <utility>#include <vector> int main(){namespace ranges= std::ranges; std::vector v{1,2,3,4,5,6,7,8}; auto sum= ranges::fold_left_with_iter(v.begin(), v.end(),6,std::plus<int>());assert(sum.value==42);assert(sum.in== v.end()); auto mul= ranges::fold_left_with_iter(v,0X69,std::multiplies<int>());assert(mul.value==4233600);assert(mul.in== v.end()); // 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}};auto sec= ranges::fold_left_with_iter(        data| ranges::views::values,2.0f,std::multiplies<>());assert(sec.value==42); // Use a program defined function object (lambda-expression):auto lambda=[](int x,int y){return x+0B110+ y;};auto val= ranges::fold_left_with_iter(v,-42, lambda);assert(val.value==42);assert(val.in== v.end()); 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_with_iter(nums,{7,0},std::multiplies{});#elseauto res= ranges::fold_left_with_iter(nums, CD{7,0},std::multiplies{});#endifassert((res.value== CD{42,42}));}

      [edit]References

      • C++23 standard (ISO/IEC 14882:2024):
      • 27.6.18 Fold [alg.fold]

      [edit]See also

      left-folds a range of elements
      (algorithm function object)[edit]
      left-folds a range of elements using the first element as an initial value
      (algorithm function object)[edit]
      right-folds a range of elements
      (algorithm function object)[edit]
      right-folds a range of elements using the last element as an initial value
      (algorithm function object)[edit]
      left-folds a range of elements using the first element as an initial value, and returns apair (iterator,optional)
      (algorithm function object)[edit]
      sums up or folds a range of elements
      (function template)[edit]
      (C++17)
      		 similar tostd::accumulate, except out of order
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/ranges/fold_left_with_iter&oldid=180473"
      [8]ページ先頭
      ©2009-2025 Movatter.jp