<Functional>: plus<long>() on integers gives unexpected result - c++

Question

I don’t understand why I do not get the same results in these two cases:
#include <iostream>
#include <vector>
#include <numeric> // for accumulate
#include <functional> // for plus()
using namespace std;
int main() {
long long i = (long long) 0xFFFFFFFF + 2;
cout << i << endl;
vector<int> v;
v.push_back(0xFFFFFFFF);
v.push_back(2);
long long r = accumulate(v.begin(), v.end(), 0, plus<long long>());
cout << r << endl;
return 0;
}
Anyone any ideas?
EDIT: as correctly pointed out below, this is due to the sign bit in int I wasn't counting on. 0x7FFFFFFF would obviously be better for testing. Also, I erroneously expected that the return type of plus() would be the same as for accumulate(), which is not the case: it is based on the third argument.

Answer 1

There are two problems here:
The number 0xFFFFFFFF won't fit in an int (assuming 32-bit ints), so the value stored in the vector is actually -1 on most implementations. Using vector<unsigned int> or vector<long long> should fix this.
The type returned by accumulate is the type deduced from the third parameter. Since you passed in 0, this will be int. You should pass in 0LL instead so that it returns long long.
This program with both fixes will return the correct result:
#include <iostream>
#include <vector>
#include <numeric> // for accumulate
#include <functional> // for plus()
using namespace std;
int main() {
long long i = (long long) 0xFFFFFFFF + 2;
cout << i << endl;
vector<long long> v; //or vector<unsigned int>
v.push_back(0xFFFFFFFF);
v.push_back(2);
long long r = accumulate(v.begin(), v.end(), 0LL, plus<long long>());
cout << r << endl;
return 0;
}

Answer 2

Because your vector contains type int and 0xFFFFFFFF doesn't fit into it. Try to change it to long long.
#include <iostream>
#include <vector>
#include <numeric> // for accumulate
#include <functional> // for plus()
using namespace std;
int main() {
long long i = (long long) 0xFFFFFFFF + 2;
cout << i << endl;
vector<long long> v;
v.push_back(0xFFFFFFFF);
v.push_back(2);
long long r = accumulate(v.begin(), v.end(), 0LL, plus<long long>());
cout << r << endl;
return 0;
}
EDIT:
Also, as pointed by interjay, third parameter should have type long long since accumulate uses it to deduce resulting type.

Answer 3

Your vector stores type int which is probably a 32 bit type. From 4.7/3 we learn:
If the destination type is signed, the value is unchanged if it can be
represented in the destination type (and bit-field width); otherwise,
the value is implementation-defined.
In other words, your value 0xFFFFFFFF can't be represented in the destination signed type so the results are implementation defined. In this case, it most likely took the obvious twos-comp result and stored a -1 in the vector. Then when you do the accumulate, it adds -1 (because it doesn't change the stored -1) and 2, resulting in the 1 being printed.
Most likely you wanted to store long long in the vector (since you're summing values larger than a 32 bit can hold), and as noted in other answers you would also need to pass 0LL to accumulate to force it to infer the correct return type.