accumulate


Category: algorithms 
Component type: function 
Prototype
Accumulate is an overloaded name; there are actually two accumulate
functions.
template <class InputIterator, class T>
T accumulate(InputIterator first, InputIterator last, T init);
template <class InputIterator, class T, class BinaryFunction>
T accumulate(InputIterator first, InputIterator last, T init,
BinaryFunction binary_op);
Description
Accumulate is a generalization of summation: it computes the sum
(or some other binary operation) of init and all of the elements
in the range [first, last). [1]
The function object binary_op is not required to be either
commutative or associative: the order of all of accumulate's operations
is specified. The result is first initialized to init. Then, for each
iterator i in [first, last), in order from beginning to end,
it is updated by result = result + *i (in the first version) or
result = binary_op(result, *i) (in the second version).
Definition
Defined in the standard header numeric, and in the nonstandard
backwardcompatibility header algo.h.
Requirements on types
For the first version, the one that takes two arguments:

InputIterator is a model of Input Iterator.

T is a model of Assignable.

If x is an object of type T and y is an object of
InputIterator's value type, then x + y is defined.

The return type of x + y is convertible to T.
For the second version, the one that takes three arguments:

InputIterator is a model of Input Iterator.

T is a model of Assignable.

BinaryFunction is a model of Binary Function.

T is convertible to BinaryFunction's first argument type.

The value type of InputIterator is convertible to
BinaryFunction's second argument type.

BinaryFunction's return type is convertible to T.
Preconditions

[first, last) is a valid range.
Complexity
Linear. Exactly last  first invocations of the binary operation.
Example
int main()
{
int A[] = {1, 2, 3, 4, 5};
const int N = sizeof(A) / sizeof(int);
cout << "The sum of all elements in A is "
<< accumulate(A, A + N, 0)
<< endl;
cout << "The product of all elements in A is "
<< accumulate(A, A + N, 1, multiplies<int>())
<< endl;
}
Notes
[1]
There are several reasons why it is important that accumulate
starts with the value init. One of the most basic is that this
allows accumulate to have a welldefined result even if [first,
last) is an empty range: if it is empty, the return value is init.
If you want to find the sum of all of the elements in [first, last),
you can just pass 0 as init.
See also
inner_product, partial_sum, adjacent_difference,
count
Copyright ©
1999 Silicon Graphics, Inc. All Rights Reserved.
TrademarkInformation