Difference between revisions of "cpp/algorithm/accumulate"
(P0616R0) |
m (Text replace - "par req concept" to "par req named") |
||
| Line 28: | Line 28: | ||
{{par op2 | op | t1=T | p2=InputIt | rt=T | The binary operator takes the current accumulation value {{tt|a}} (initialized to {{tt|init}}) and the value of the current element {{tt|b}}. }} | {{par op2 | op | t1=T | p2=InputIt | rt=T | The binary operator takes the current accumulation value {{tt|a}} (initialized to {{tt|init}}) and the value of the current element {{tt|b}}. }} | ||
{{par hreq}} | {{par hreq}} | ||
| − | {{par req | + | {{par req named | InputIt | InputIterator}} |
| − | {{par req | + | {{par req named | T | CopyConstructible | CopyAssignable}} |
{{par end}} | {{par end}} | ||
Revision as of 15:04, 15 June 2018
| Defined in header <numeric>
|
||
| template< class InputIt, class T > T accumulate( InputIt first, InputIt last, T init ); |
(1) | |
| template< class InputIt, class T, class BinaryOperation > T accumulate( InputIt first, InputIt last, T init, |
(2) | |
Computes the sum of the given value init and the elements in the range [first, last). The first version uses operator+ to sum up the elements, the second version uses the given binary function op, both applying std::move to their operands on the left hand side(since C++20).
|
|
(until C++11) |
|
|
(since C++11) |
Contents |
Parameters
| first, last | - | the range of elements to sum |
| init | - | initial value of the sum |
| op | - | binary operation function object that will be applied. The binary operator takes the current accumulation value a (initialized to init) and the value of the current element b. 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 have const &. |
| Type requirements | ||
-InputIt must meet the requirements of LegacyInputIterator.
| ||
-T must meet the requirements of CopyAssignable and CopyConstructible.
| ||
Return value
Notes
std::accumulate performs a left fold. In order to perform a right fold, one must reverse the order of the arguments to the binary operator, and use reverse iterators.
Possible implementation
| First version |
|---|
template<class InputIt, class T> T accumulate(InputIt first, InputIt last, T init) { for (; first != last; ++first) { init = std::move(init) + *first; // std::move since C++20 } return init; } |
| Second version |
template<class InputIt, class T, class BinaryOperation> T 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; } |
Example
#include <iostream> #include <vector> #include <numeric> #include <string> #include <functional> 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>()); std::string s = std::accumulate(std::next(v.begin()), v.end(), std::to_string(v[0]), // start with first element [](std::string a, int b) { return a + '-' + std::to_string(b); }); std::cout << "sum: " << sum << '\n' << "product: " << product << '\n' << "dash-separated string: " << s << '\n'; }
Output:
sum: 55 product: 3628800 dash-separated string: 1-2-3-4-5-6-7-8-9-10
See also
| computes the differences between adjacent elements in a range (function template) | |
| computes the inner product of two ranges of elements (function template) | |
| computes the partial sum of a range of elements (function template) | |
| (C++17) |
similar to std::accumulate, except out of order (function template) |
