1

I am trying to left shifting with char variable. It's giving strange output. According to C standard, Range of signed char is 127 to -128, So I output will be -128 of following program but it's printing 640.

#include <stdio.h>

int main()
{
    char c = 5;
    
    printf("%d\n", (c << 7));
    
    return 0;
}

Is it undefined behavior?

Online compiler : Wandbox

Jayesh
  • 4,755
  • 9
  • 32
  • 62
  • 3
    When used in expressions and passed as argument to a varargs function like `printf`, all`char` types will be *promoted* to an `int`. Including sign-extension. To print it as a small integer use `%hhd`. – Some programmer dude Nov 18 '21 at 09:28
  • 3
    Also, it's *implementation defined* (i.e. up to the compiler) if `char` is signed or unsigned. For bitwise expression I recommend you use explicit unsigned types, i.e. `unsigned char` (or `uint8_t`). – Some programmer dude Nov 18 '21 at 09:30
  • Does this answer your question? [I don't really know why bit-shifting works in one scenario but not the other](https://stackoverflow.com/questions/61433792/i-dont-really-know-why-bit-shifting-works-in-one-scenario-but-not-the-other) – phuclv Nov 18 '21 at 09:31
  • [shifting an unsigned char by more than 8 bits](https://stackoverflow.com/q/62666302/995714) – phuclv Nov 18 '21 at 09:31
  • *"...Size of signed char is 127 to -128"* -- wrong! The size is 1 byte, it (signed char) can store values ranging from 127 to -128. – WedaPashi Nov 18 '21 at 09:36

2 Answers2

2

Actually it is implicitly type casted to int type. That's why you are getting unexpected output.

Type cast explicitly to get expected output.

printf("%d\n", (char) (c << 7));

Or

You can do this

c = (char)(c<< 7);
msc
  • 33,420
  • 29
  • 119
  • 214
0

1. "...but it's printing 640..." ?

Since the 8-bit binary number for 5 is 00000101, c << 7 results in a 32-bit binary number 0...(other 20 0s)...01010000000, which is 640 in decimal.

2. "...Is it undefined behavior..." ?

No, the behavior is defined by the standard. This behavior consists of two major processes, one is Bitwise Shift Operators, and the other is Integer Promotions.

For Bitwise Shift Operators, in C99 6.5.7 p3:

The integer promotions are performed on each of the operands. The type of the result is that of the promoted left operand.

For Integer Promotions, in C99 6.3.1.1 p2:

An object or expression with an integer type whose integer conversion rank is less than or equal to the rank of int and unsigned int.
If an int can represent all values of the original type, the value is converted to an int;

Accoding to these definitions, the result of c << 7 would eventually be an int type number 640, whose bit pattern is 0...(other 20 0s)...01010000000.

One workaround is doing as what @msc suggested, that is, (char) c << 7, which has the effect that roughly described as follows:

#1: (char)c<<7  

   ——————> 0...(other 20 0s)...01010000000  
   ——————> (Promotion & Truncation happened)
   ——————> 10000000   

#2: %d

   ——————> (Promotion & Sign Extension happened)
   ——————> 1...(other 20 1s)...11110000000  
  
#3: printf  

   ——————> 1...(other 20 1s)...11110000000   ->   -128
Michael Lee
  • 197
  • 8