Problem with multiplication of signed chars

Question

Discussing this answer I find out that the code bellow prints -1 and 1 in visual studio. Why? In my opinion it should print two 1s despit overflow during multiplication.

signed char c1 = numeric_limits<signed char>::min();
signed char c2 = -1;
cout << c1 * c2 / c1 << endl;
signed char result = c1 * c2;
cout << result / c1 << endl;

CB Bailey · Accepted Answer · 2011-04-30T10:17:10.490

4

c1 might have a value like -128, say. In the multiplication, integer promotions will cause both c1 and c2 to be converted to type int before the operation is performed.

c1 * c2 is then going to be a int with value 128 so c1 * c2 / c1 is going to be an int with value -1.

-1 for the first output looks correct to me.

For the second version, typically the assignment of the result of c1 * c2 won't fit into a signed char and will convert to an implementation-defined result, perhaps -128 instead of 128.

edited Apr 30 '11 at 10:17

answered Apr 30 '11 at 10:09

CB Bailey

755,051
104
632
656

But why `c1 * c2` is going to be an `int`? Is this standart? – Mihran Hovsepyan Apr 30 '11 at 10:12
@Mihran because of integer promotion – There is nothing we can do Apr 30 '11 at 10:14
@MihranHovespyan: Integral promotions apply to both operands of `*` so both `signed char` will be promoted to `int` before the multiplication is performed. – CB Bailey Apr 30 '11 at 10:14
As weird as it may look, you can verify this with a simple test program: `void foo(int) { std::cout << "int"; } void foo(char) { std::cout << "char"; } int main() { char a=1, b=2; foo(a*b); }`, the output of which will be "int" (the same goes for other arithmetic operations) – David Rodríguez - dribeas Apr 30 '11 at 10:58

score 2 · Answer 2 · edited May 23 '17 at 10:24

2

Integer overflow is considered UB. This means that the compiler will consider (c1 * c2 / c1) to be completely equivalent to c2.

You can check this for additional info.

edited May 23 '17 at 10:24

Community

1
1

answered Apr 30 '11 at 10:08

ruslik

14,714
1
39
40

2

`c1 * c2` probably doesn't involve any _signed_ integer overflow unless the platform has identically sized `char` and `int`. – CB Bailey Apr 30 '11 at 10:11
@Charles: which it doesn't (it's Visual Studio). – Steve Jessop Apr 30 '11 at 10:17

Steve Jessop · Answer 3 · 2011-04-30T10:21:30.783

c1 * c2 is an int multiplication (5/9 in the standard). We know that CHAR_BIT is 8 on MSVC and that it uses two's complement representation for signed types, so we know the value: -128 * -1 is 128.

128 / -128 is -1, so that's the first result sorted.

Assigning -CHAR_MIN to a signed char has implementation-defined results (4.7/3), but we know in MSVC the result is -128. Then -128 / -1 is 1, so that's the second result sorted.

mdma · Answer 4 · 2011-04-30T10:36:01.340

The first case, making upscaling to an int explicit:

cout << ((int)c1 * c2 / c1 << endl;

the second case, assigning to an intermediate variable is equivalent to

cout << ((signed char)((int)c1 * c2)) / c1 << endl;

(Implicit casts to int done by the compiler made explicit.)

With two's complement, multiplying the largest negative value of a type by -1 leaves the value unchanged if it is restricted to the same number of bits. So, the second example, c1*c2 == c1. Even though the multiplication is done as an int, it is cast back to the width of a char.

In the first example, the entire calaulation is done as an int, so the operation has more bits to work with, and so the truncation doesn't occur. Here, c1*c2 == (c1*-1) == -c1. Hence the different result.

The promotion to `int` is redundant, the implementation does this anyway. In this case, in `(signed char)((int)c1 * c2)` there is no overflow of an arithmetic operation, there's an explicit conversion from one integer type to another. This would be implementation-defined, not underfined behavior. — CB Bailey, Apr 30 '11 at 10:29

Problem with multiplication of signed chars

4 Answers4

Linked