C ++模板中的类型优先级和整数类型

Question

I was using std::accumulate as part of coding exercise and came across some behaviour I want to understand more fully.

The signature of accumulate is:

T accumulate( InputIt first, InputIt last, T init );

If I have code like:

std::vector<int> a = {..};
int64_t zero = 0;
int64_t csum = std::accumulate(a.begin(), a.end(), zero);

it works as I'd expect. If I change it to:

std::vector<int> a = {..};
int64_t csum = std::accumulate(a.begin(), a.end(), 0);

then I get overflows since (I think) the type of '0' is determined to be a 32bit integer, and this override the return type I actually specified (since a normal integer can be stored in a 64bit integer).

From this I infer that the compiler is generating an accumulate that looks like:

int accumulate( InputIt first, InputIt last, int init );

vs.

int64_t accumulate( InputIt first, InputIt last, int64_t); 

Is there some rule I can remember to generalise this inference to other cases?

Answer 1

The signature of accumulate is:

 T accumulate( InputIt first, InputIt last, T init ); 

The signature of accumulate is

template< class InputIt, class T >
T accumulate( InputIt first, InputIt last, T init );

Don't forget the template arguments! Templates would be a royal pain to use if one always had to specify the types. The compiler (sometimes) nicely infers what those template arguments are based on the arguments you supply.

This is one of those cases where it can and does do so. In this case, it infers that InputIt is std::vector<int>::iterator and that T is either std::int64_t (your first example) or int (your second example).

Unless you tell the compiler otherwise, it will always infer 0 to be of type int . There is a way to tell the compiler that 0 is of some other type:

std::accumulate(a.begin(), a.end(), 0L)   // T is long int
std::accumulate(a.begin(), a.end(), 0LL)  // T is long long int
std::accumulate(a.begin(), a.end(), 0U)   // T is unsigned int
std::accumulate(a.begin(), a.end(), 0UL)  // T is unsigned long int
std::accumulate(a.begin(), a.end(), 0ULL) // T is unsigned long long int