Why does std::accumulate behave like this with standard arrays?

Question

I'm just getting into C++ and I think I have a handle on pointers, but std::accumulate() has me confused.

Given the array:

int a[3] = { 5, 6, 7 };

I'd like to sum the values of the array with std::accumulate(), so I pass it a pointer to the first element, then the last, then the starting value of the accumulator.

std::accumulate(a, a + 2, 0);
std::accumulate(&a[0], &a[2], 0);

Oops: either of these returns the sum of only the first two elements: 11.

On the other hand, if the second argument is a nonsensical pointer, just out of bounds...

std::accumulate(a, a + 3, 0);
std::accumulate(&a[0], &a[3], 0);

... the correct value of 18 is returned.

Could someone please explain this? I realise that I could avoid using simple arrays, but that's beside the point.

Answer 1

C++ ranges are defined as [first, last), and all the STL algorithm work like that. In this case, std::accumulate sums up all the elements behind the iterator-defined range, starting with first and ending at last without actually dereferencing it.

Thus, calling it like std::accumulate(a, a+3, 0) is actually correct and equal to calling it with std::accumulate(begin(a), end(a), 0).

Also note that this doesn't fall foul of the "no pointers to outside of allocated arrays" rule, as there is a specific exception for pointer to just behind the last element.