I was asked the output of the following code in my interview yesterday
#include <stdio.h>
int main(void){
printf ("%x" ,-1<<4);
}
I was given 2 minutes to tell the answer. I responded fffffff0. The result of the interview has not been declared yet. I want to know was my answer correct?
Technically left-shifting a negative integer invokes Undefined Behaviour. That means -1<<4 is UB. I dont know why they asked you this question. Probably they wanted to test your depth of knowledge of the C and C++ Standards.
C99 [6.5.7/4] says
The result of E1 << E2 is E1 left-shifted E2 bit positions; vacated bits are filled with zeros. If E1 has an unsigned type, the value of the result is E1× 2E2, reduced modulo one more than the maximum value representable in the result type. If E1 has a signed type and nonnegative value, and E1× 2E2 is representable in the result type, then that is the resulting value; otherwise, the behavior is undefined.
C++03 makes it undefined behaviour by omitting the relevant text.
No. You're not correct. That's the bad news. Good news is that the interviewer probably doesn't know that and will assume you are because it's the result THEY get when they compile and run it.
True answer is that it is implementation defined. I'm not 100% confident to say it IS undefined behavior because of the overload, but I think it may be. At the very least though the result is dependent upon how negative numbers are represented, etc... Neither language you've claimed this is in define what the output will be.
On my machine:
chris@zack:~$ cat > test.c
#include <stdio.h>
int main(void){
printf ("%x" ,-1<<4);
}
chris@zack:~$ gcc -o test test.c && ./test
fffffff0
However, the result will depend on your architecture and compiler. So the correct answer is "it could output anything."
Binary of 1 : 0000 0000 0000 0000 0000 0000 0000 00001
Replace occurrence of 0 with 1 as you are going to calculate binary of negative no
How to calculate binary of negative numbers
Binary of -1 : 1111 1111 1111 1111 1111 1111 1111 11111
Left shift 4 : 1111 1111 1111 1111 1111 1111 1111 0000
Hex Representation of of resultant Left shift 4 will be
1111 : F
0000 : 0
so calculated output will be :
FFFFFFF0
Your answer is Right.
Left shifting a negative number is undefined for the general case but we have to understand why this undefined behavior (UB)? Keep in mind that Most Significant Bit (MSb) is the sign bit. If this bit is a 1 the number is negative. If it is a zero the number is positive. This is critical information is lost with the first left shift. For example
-32768<<4
is the same thing as
0x8000<<4
(assuming a 16 bit machine for simplicity)
The result is, of course, 0 which doesn't really make any sense and is therefore UB.
In the specific case of the interview question from the OP, there is only one specific value we are concerned with...not the general case. -1 (0xffffffff on a 32 bit machine) shifted left 4 times will yield 0xfffffff0 as the OP originally thought.
It's undefined behavior.
$ cat undef.c
#include <stdio.h>
int main(void){
printf ("%x" ,-1<<4);
}
$ clang -fsanitize=undefined undef.c
$ ./a.out
undef.c:3:24: runtime error: left shift of negative value -1
fffffff0
I ran this code on 3 different compilers and OS. All gave me this same answer as mentioned in the question. Until and unless someone came up with the compiler on which this is really undefined behavior, I will say the answer is RIGHT. If this is stable in 99.99% of the situations, then there are more chances of standard getting changed, than the compiler stop supporting it.
I just wrote the code in a text file, compiled it, and YES, the answer is correct.
