Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::accumulate

      From cppreference.com
      <cpp‎ |algorithm
       
       
      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
       
       
      Defined in header<numeric>
      template<class InputIt,class T>
      T accumulate( InputIt first, InputIt last, T init);
      (1)(constexpr since C++20)
      template<class InputIt,class T,class BinaryOp>
      T accumulate( InputIt first, InputIt last, T init, BinaryOp op);
      (2)(constexpr since C++20)

      Computes the sum of the given valueinit and the elements in the range[firstlast).

      1) Initializes the accumulatoracc (of typeT) with the initial valueinit and then modifies it withacc= acc+*i(until C++20)acc= std::move(acc)+*i(since C++20) for every iteratori in the range[firstlast) in order.
      2) Initializes the accumulatoracc (of typeT) with the initial valueinit and then modifies it withacc= op(acc,*i)(until C++20)acc= op(std::move(acc),*i)(since C++20) for every iteratori in the range[firstlast) in order.

      If any of the following conditions is satisfied, the behavior is undefined:

      Contents

      [edit]Parameters

      first, last - the pair of iterators defining therange of elements to accumulate
      init - initial value of the accumulate
      op - binary operation function object that will be applied.

      The signature of the function should be equivalent to the following:

       Ret fun(const Type1&a,const Type2&b);

      The signature does not need to haveconst&.
      The type Type1 must be such that an object of typeT can be implicitly converted to Type1. The type Type2 must be such that an object of typeInputIt can be dereferenced and then implicitly converted to Type2. The typeRet must be such that an object of typeT can be assigned a value of typeRet.​

      Type requirements
      -
      InputIt must meet the requirements ofLegacyInputIterator.

      [edit]Return value

      acc after all modifications.

      [edit]Possible implementation

      accumulate (1)
      template<class InputIt,class T>constexpr// since C++20T accumulate(InputIt first, InputIt last, T init){for(; first!= last;++first)        init= std::move(init)+*first;// std::move since C++20 return init;}
      accumulate (2)
      template<class InputIt,class T,class BinaryOperation>constexpr// since C++20T accumulate(InputIt first, InputIt last, T init, BinaryOperation op){for(; first!= last;++first)        init= op(std::move(init),*first);// std::move since C++20 return init;}

      [edit]Notes

      std::accumulate performs a leftfold. In order to perform a right fold, one must reverse the order of the arguments to the binary operator, and use reverse iterators.

      If left to type inference,op operates on values of the same type asinit which can result in unwanted casting of the iterator elements. For example,std::accumulate(v.begin(), v.end(),0) likely does not give the result one wishes for whenv is of typestd::vector<double>.

      [edit]Example

      Run this code
      #include <functional>#include <iostream>#include <numeric>#include <string>#include <vector> int main(){std::vector<int> v{1,2,3,4,5,6,7,8,9,10}; int sum= std::accumulate(v.begin(), v.end(),0);int product= std::accumulate(v.begin(), v.end(),1,std::multiplies<int>()); auto dash_fold=[](std::string a,int b){return std::move(a)+'-'+std::to_string(b);}; std::string s= std::accumulate(std::next(v.begin()), v.end(),std::to_string(v[0]),// start with first element                                    dash_fold); // Right fold using reverse iteratorsstd::string rs= std::accumulate(std::next(v.rbegin()), v.rend(),std::to_string(v.back()),// start with last element                                     dash_fold); std::cout<<"sum: "<< sum<<'\n'<<"product: "<< product<<'\n'<<"dash-separated string: "<< s<<'\n'<<"dash-separated string (right-folded): "<< rs<<'\n';}

      Output:

      sum: 55product: 3628800dash-separated string: 1-2-3-4-5-6-7-8-9-10dash-separated string (right-folded): 10-9-8-7-6-5-4-3-2-1

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      LWG 242C++98op could not have side effectsit cannot modify the ranges involved

      [edit]See also

      computes the differences between adjacent elements in a range
      (function template)[edit]
      computes the inner product of two ranges of elements
      (function template)[edit]
      computes the partial sum of a range of elements
      (function template)[edit]
      (C++17)
      similar tostd::accumulate, except out of order
      (function template)[edit]
      left-folds a range of elements
      (algorithm function object)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/accumulate&oldid=180318"

      [8]ページ先頭

      ©2009-2025 Movatter.jp