Unexpected output with left shift operator C++

Question

Here is the code which is giving me the unexpected answer

#include<bits/stdc++.h>
using namespace std;
int main()
{
    cout<<(1<<50);
}

The answer I get is 0. But if I change the line to

cout<<pow(2, 50);

I get the right answer.

Could someone explain me the reason.

integer overflow is my guess. (`main.cpp:5:20: warning: left shift count >= width of type [-Wshift-count-overflow]` compiler warnings are your friends, listen to them) — Borgleader, Jun 28 '17 at 12:40
by the way, do **not** use `#include` - it's not standard compliant — UnholySheep, Jun 28 '17 at 12:41
consider `pow` returns a `double`, which may actually be able to represent 2^50, while `1<<50` is an `int`, which can't — Federico klez Culloca, Jun 28 '17 at 12:41
@StoryTeller sometimes I am not sure about something and just post it even if there are high chances that it is wrong. Once again I learned something. Thx, I better remove the comment, not because of my shame, but not to confuse others that are as ignorant as me ;) — 463035818_is_not_an_ai, Jun 28 '17 at 12:48
@VarunSaproo - It's the largest fundamental integral data type. On modern systems it's most likely 64 bit. Don't assume it *has* to be 64 bit. — StoryTeller - Unslander Monica, Jun 28 '17 at 12:51

score 3 · Answer 1 · answered Jun 28 '17 at 12:42

3

Assuming your compiler treats the constant 1 as a 32bit integer, you shifted it so far to the left, that only zeroes remain in the 32bit you have. 50 is larger than 32.

answered Jun 28 '17 at 12:42

nvoigt

75,013
26
93
142

So is there any way I could shift to 50? – Varun Saproo Jun 28 '17 at 12:45
Try `1ULL << 50`. – sharyex Jun 28 '17 at 12:50
@VarunSaproo Sure, just put your constant into a 64bit variable. For example `int64_t` from `#include `. – nvoigt Jun 28 '17 at 12:50

Vlad from Moscow · Answer 2 · 2017-06-28T12:52:18.367

From the C++ Standard (5.8 Shift operators)

1 The shift operators << and >> group left-to-right.

shift-expression:
    additive-expression
    shift-expression << additive-expression
    shift-expression >> additive-expression

The operands shall be of integral or unscoped enumeration type and integral promotions are performed. The type of the result is that of the promoted left operand. The behavior is undefined if the right operand is negative, or greater than or equal to the length in bits of the promoted left operand.

Take into account that the behavior also will be undefined if the right operand is not greater or equal to the length in bits of the left operand but can touch the sign bit because the integer literal 1 has the type signed int.

As for this function call pow(2, 50) then there is used some algorithm that calculates the power.

zdf · Answer 3 · 2017-06-28T12:52:15.310

2

Try this (run it):

#include <iostream>

int main()
{
  std::int64_t i { 1 }; // wide enough to allow 50 bits shift
  std::cout << std::hex << ( i << 50 );  // should display 4000000000000
  return 0;
}

edited Jun 28 '17 at 12:52

answered Jun 28 '17 at 12:46

zdf

4,382
3
18
29

Loamsiada · Accepted Answer · 2017-06-28T12:48:29.103

1

You shift the "1" out of the 32 bit field, so zero is the result. Pow uses float representation where 2^50 can be handled.

EDIT

Without any modifications like "1LL" or "1ULL" (which generate long 64bit numbers), an integer number is usually handled as 32 bit on a x64 or x86 architectures. You can use

 cout << (1ULL << 50);

or

 cout << ((long long)1 << 50);

which should to it.

edited Jun 28 '17 at 12:48

answered Jun 28 '17 at 12:43

Loamsiada

444
3
11

What 32bit field? – UnholySheep Jun 28 '17 at 12:43
3

Note that `int` may or may not be 32bit large. – Rakete1111 Jun 28 '17 at 12:43
1 is handled as a signed integer number which has 32 bit on a common PC. – Loamsiada Jun 28 '17 at 12:44
@ThomasJahn What if I don't use a common PC? You should definitely mention that. – Rakete1111 Jun 28 '17 at 12:45
The size of a signed integer number is chosen by the compiler (which will most likely choose one that is well suited for the target architecture, but that's not required), the standard only states that `int` has to be at least 16 bits wide. – UnholySheep Jun 28 '17 at 12:46
"cout << (static_cast(1) << 50) << endl;" also works, and fully documents the size of integer you intended. (static_cast(1) << 50) too – 2785528 Jun 29 '17 at 00:32

score 1 · Answer 5 · answered Jun 28 '17 at 12:44

It's exactly what you're doing. You're shifting a single bit by 50 position in a portion of memory that's 32 bit... What's happening according to you? The bit goes somewhere else but it's not inside the memory portion of the integer anymore. pow(2, 50) performs a double casting, so you're not shifting bits anymore.

Also, never use #include<bits/stdc++.h>. It's not standard, and it's slow. You should use it only in precompiled headers but I'd avoid this also in that cases.

score 0 · Answer 6 · answered Jun 28 '17 at 12:49

0

cout<<(1<<50);

Your code treats 1 as an int, so overflows. Instead, try:

cout << (1ULL << 50);

answered Jun 28 '17 at 12:49

Baldrickk

4,291
1
15
27

Unexpected output with left shift operator C++

6 Answers6