CODEWITHSUNDEEP
c++infinite-loop
Lubulos
Lubulos

Reputation: 290

Question on Infinte Loop in C++

This is kind of a curiosity.

I'm studying C++. I was asked to reproduce an infinite loop, for example one that prints a series of powers:

#include <iostream>

int main()
{
    int powerOfTwo = 1; 

    while (true)
    {
        powerOfTwo *= 2;
        cout << powerOfTwo << endl;
    }
}

The result kinda troubled me. With the Python interpreter, for example, I used to get an effective infinite loop printing a power of two each time it iterates (until the IDE would stop for exceeding iteration's limit, of course). With this C++ program instead I get a series of 0. But, if I change this to a finite loop, and that is to say I only change the condition statement to:

(powerOfTwo <= 100)

the code works well, printing 2, 4, 16, ..., 128.

So my question is: why an infinite loop in C++ works in this way? Why it seems to not evaluate the while body at all?

Edit: I'm using Code::Blocks and compiling with g++.

Upvotes: 2

Views: 506

Answers (7)

Robᵩ
Robᵩ

Reputation: 168716

Carefully examine the output of the program. You don't really get an infinite series of zeroes. You get 32 numbers, followed by an infinite series of zeroes.

The thirty-two numbers are the first thirty-two powers of two:

1
2
4
8
...
(2 raised to the 30th)
(2 raised to the 31st)
0
0
0

The problem is how C represents numbers, as finite quantities. Since your mathematical quantity is no longer representable in the C int, C puts some other number in its place. In particular, it puts the true value modulo 2^32. But 2^32 mod 2^32 is zero, so there you are.

Upvotes: 0

Vinay
Vinay

Reputation: 2594

I guess you know all data-type concept in C,C++, so you are declaring powerOfTwo as a integer. so the range of integer get followed accordingly, if you want an continuous loop you can use char as datatype and by using data conversion you can get infinite loop for you function.

Upvotes: 0

Chris Vig
Chris Vig

Reputation: 8792

In Python, integers can hold an arbitrary number of digits. C++ does not work this way, its integers only have a limited precision (normally 32 bits, but this depends on the platform). Multiplication by 2 is implemented by bitwise shifting an integer one bit to the left. What is happening is that you initially have only the first bit in the integer set:

powerOfTwo = 1; // 0x00000001 = 0b00000000000000000000000000000001

After your loop iterates 31 times, the bit will have shifted to the very last position in the integer.

powerOfTwo = -2147483648; // 0x80000000 = 0b10000000000000000000000000000000

The next multiplication by two, the bit is shifted all the way out of the integer (since it has limited precision), and you end up with zero.

powerOfTwo = 0; // 0x00000000 = = 0b00000000000000000000000000000000

From then on, you are stuck, since 0 * 2 is always 0. If you watch your program in "slow motion", you would see an initial burst of powers of 2, followed by an infinite loop of zeroes.

In Python, on the other hand, your code would work as expected - Python integers can expand to hold any arbitrary number of digits, so your single set bit will never "shift off the end" of the integer. The number will simply keep expanding so that the bit is never lost, and you will never wrap back around and get trapped at zero.

Upvotes: 6

Andres
Andres

Reputation: 3414

In C++ you will cause an overflow pretty soon, your int variable won't be able to handle big numbers.

int: 4 bytes signed can handle the range –2,147,483,648 to 2,147,483,647

So as @freerider said, your compiler is maybe optimizing the code for you.

Upvotes: 0

Ed Heal
Ed Heal

Reputation: 60017

I c++ it has a limited size - so therefore is able to compute even if errror

but the whole true makes the case

Upvotes: 0

Andrey
Andrey

Reputation: 60075

Actually it prints powers of two until powerOfTwo gets overflowed and becomes 0. Then 0*2 = 0 and so on. http://ideone.com/XUuHS

Upvotes: 0

totowtwo
totowtwo

Reputation: 2147

In the infinite loop case you see 0 because the int overflows after 32 iterations to 0 and 0*2 == 0.

Look at the first few lines of output. http://ideone.com/zESrn 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768 65536 131072 262144 524288 1048576 2097152 4194304 8388608 16777216 33554432 67108864 134217728 268435456 536870912 1073741824 -2147483648 0 0 0

Upvotes: 7

Related Questions