C++ Brain Teasers: Exercise Your Mind/

...

/

Discussion: A Little Sum Thing

Discussion: A Little Sum Thing

Execute the code to understand the output and gain insights into integer type conversions and arithmetic behavior.

We'll cover the following...

Run the code

Now, it’s time to execute the code and observe the output.

Press + to interact
#include <iostream>
#include <numeric>
#include <vector>
int main()
{
    std::vector<int> v{-2, -3};
    std::cout << std::accumulate(v.cbegin(), v.cend(), v.size());
}

Understanding the output

The size of the vector is 2. When we add -2 and -3 to it, why is the result not -3?

The std::accumulate() function template is defined like so:

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

This computes its result by initializing the accumulator acc with the initial value init and then modifies it with acc = std::move(acc) + *i (…) for every iterator i in the [first, last) range in order.

Template parameter deduction

Let’s start by deducing the template parameters. The InputIterator will be deduced to the iterator type for the vector, which isn’t interesting for this puzzle since it’s only used for iterating. T, on the other hand, will be deduced to the type of std::vector<int>::size(), which is key to the puzzle. The std::vector<int>::size() returns size_type, which is not specified in detail by the standard. It’s only required to be an unsigned integer type, and as long as that requirement is met, the implementation can choose whatever representation is natural to use on that particular system.

So both the type of init and the return type, as well as the accumulator acc that’s inside std::accumulate() will be of this unsigned integer type size_type. When we add negative numbers to an unsigned type, something is bound to go wrong. But what exactly? And, importantly, is it undefined behavior?

Major error scenarios

Two error scenarios are worrisome:

  • Integer type conversion: When converting a value of one integer type to another integer type, if the value is out of range for the new type. This is not as dangerous as it sounds, as the operation doesn’t actually overflow but rather wraps around. This is true both for unsigned integers and, as of C++20, also for signed integers. For example, an 8-bit signed integer such as int8_t can represent values from -128 to 127. If we try to assign the value 128 to it, which is one too large, it wraps around to -128. When a value wraps around, we’re bound to get a wrong result, but at least it’s not undefined behavior.

  • Arithmetic overflow: When doing arithmetic, if the result is out of range for the result type. For unsigned integers, we again wrap around. For signed integers, however, we get overflow, which is undefined behavior. ...

What happens in