What does accumulate do in C++? - c++

Question

i'm new to c++, recently I discovered a function called accumulate(). I searched over internet about what it is, and read the C++ Reference tutorial, but couldn't understand what it does
#include <iostream>
#include <numeric>
using namespace std;
int main ()
{
int init = 100;
int numbers[] = {10,20,30};
cout << accumulate(numbers,numbers+3,init) << "\n";
}
Why is the output of the above program 160? I would like to know what the function does and how it works. Any types help appreciated.

Answer 1

accumulate without a special function takes two iterators and returns the sum, your init specifies the starting variable. It's like fold or a functional "reduce." The code above gives 160 because it's calculating
100 + 10 + 20 + 30
numbers will be a pointer to the beginning of the array, numbers+3 is "one-past-end" a typical c++ iterator idiom. It might be clearer if it was written out as
#include <iostream>
#include <iterator>
#include <numeric>
int main ()
{
int init = 100;
int numbers[] = {10,20,30};
std::cout << std::accumulate(std::begin(numbers), std::end(numbers), init) << "\n";
}
It should be clearer in this example what the range is, the beginning of numbers to the end of numbers. The init variable becomes vital in different cases such as an empty sequence.
You could also specify a different function to use instead of addition, the following will result in init * 10 * 20 * 30
int mul(int a, int b) {
return a * b;
}
int main ()
{
int init = 100;
int numbers[] = {10,20,30};
std::cout << std::accumulate(std::begin(numbers), std::end(numbers), 1, mul) << "\n";
}
Though such simple functions are often written as lambdas

Answer 2

We can represent the function like this :
accumulate(first, last, init)
Here accumulate() function sums up all the values in the range [first,last) that is between first and (last-1) index
And here init is the initial value of the sum.
The function is similar to the following c++ code :
#include <iostream>
#include <numeric>
using namespace std;
int main ()
{
int init = 100;
int numbers[] = {10,20,30};
int first = 0, last = 3;
int sum = init;
for(int i = first ;i < last ;i++)
sum = sum + numbers[i];
cout << sum << "\n";
}
So in your example : init + number[0] + number[1] + number[2] = 100 + 10 + 20 +30 = 160
One more thing :
accumulate(numbers, numbers + 3, init)
You may ask, why we are passing numbers in the first parameter rather than 0 ?
The answer is :
Here accumulate() function does not know which array you are willing to sum up.
So you need to inform the starting address that is address of numbers[0] to the function.
And if you want to sum up element between x position to y-1 position. You have to write this :
accumulate(numbers + x, numbers + y, init)

Answer 3

std::accumulate
is what it's name suggests. It just sums up the whole sequence. In addition you can provide an initial value. In your case initial value is 100.

Answer 4

Well, if you read the documentation it says
Returns the result of accumulating all the values in the range
[first,last) to init.
So...
numbers = 10 + 20 + 30 = 60 , init = 100 => 100+60 => 160.
std::accumulate is taking as first iterator, number, and last iterator number+3.