I'm just write this code but I don't know how it works.
Why the value of k will be negative? How?
#include<iostream>
using namespace std;
int main()
{
int k=1,j=0;
while(k>j)
{
j=k;
k++;
}
cout<<j<<"\n"<<k;
}
it shows the range of an integer
int has a limited range. At some time, k++ overflows this limit. After that point, the behavior is undefined and anything can happen.
If the compiler is very conservative, then it will simply overflow to negative values (particularly in the near-ubiquitous case where int is 2's complement), but that is not guaranteed. In that case, the while loop will terminate.
Look at what gcc does with and without optimization. Both behaviors are legal according the standard, as signed overflow behavior is undefined.
With optimization (infinite loop):
main:
.L2:
jmp .L2
Without optimization: Prints:
2147483647
-2147483648
Again, anything can happen, not only the above two behaviors. Signed overflow is undefined.
The behaviour of your code is undefined due to the overflow of a signed integral type.
There is no defined way by which k can become negative. Because of that, a good compiler (optimising gcc for example) may well compile while(k > j) to, effectively, while(true).
Your code will keep on incrementing the variable k because the condition k > j is true. At some point k will get equal to the maximum int value supported on your system. When you do k++ in the next loop, the result is not representable as an int. This is called integer overflow and according to the standard, the code has undefined behavior. As it is undefined behavior we can't say what will happen in general - it is system specific.
On many system the result of incrementing the maximum intvalue will result in the minimum int value. On such systems your code is equivalent to the code:
#include<iostream>
#include <limits>
int main()
{
int j = std::numeric_limits<int>::max();
int k = j + 1;
std::cout << j << std::endl << k << std::endl;
return 0;
}
On my system the output is:
2147483647
-2147483648
But do not expect this to hold for all systems. On other systems the program may crash, or enter an endless loop or do whatever... it is undefined by the standard.
A better way to write the code so that it will work on all systems is:
#include<iostream>
#include <limits>
int main()
{
int j = std::numeric_limits<int>::max();
int k = std::numeric_limits<int>::min();
std::cout << j << std::endl << k << std::endl;
return 0;
}
In your code, k is always one greater than j at the time of the test, until it exceeds the maximum value that can be represented by an int. Then (in your case, as evidenced by your question -- it is indeed not defined by the standard) it rolls over to the other end of the range: the maximum negative value.
the while goes on until j is 2147483647
2147483647 +1 = -2147483648
the integer 32bit overflows and become negative, stopping the while.
