printing an int in C

[AnilM823]

ok.. simple question here: if you're to print out an integer before giving it a value, it prints out some huge absurd value. Where is this value coming from?

For example, if I were to do:

int i;
print ("i = %d", i);

it would print out some huge value like 1073828704. where is this value coming from? I'm not printing out the address of the variable or anything, so...?

[gpraghuram]

ok.. simple question here: if you're to print out an integer before giving it a value, it prints out some huge absurd value. Where is this value coming from?

For example, if I were to do:

int i;
print ("i = %d", i);

it would print out some huge value like 1073828704. where is this value coming from? I'm not printing out the address of the variable or anything, so...?

If the integer you are printing is inside a function then it is a auto variable and it contains always garbage as the variable gets loaded to stack every time the functions gets into the stack.
For global and static variables it will be default initialized to 0.

Raghuram

[Ganon11]

Basically, here's what happens when you say:

int x;

inside your C program. Your computer will see that you need space for an integer. Let's say you need 8 bits (1 byte) to hold an integer. The computer finds a place in main memory that can hold your integer x. Let's say it picks a position 13 of a byte to store x in. Memory position 13 might have had some random bits already stored there, such as:

0110 1101

When the computer allocates memory, it leaves the data there unchanged. It merely says, "This position (in this case, position 13) is now the value of x!" And it is so. I'll repeat; during allocation, the pre-existing data still remains.

When you print x before initializing it yourself, you get the previous value, which wouldn't make sense in the context of your program. It might be 109, as above, it might be 1073828704, it might be 9382174, it might be -3284721341, who knows?

It is this reason that you should always initialize your variables, either to some convenient constant (0 or 1), or immediately use input to assign a variable. Any way you can, get some value into your variable before you use it.

The simplest way to do this is by replacing the above code with:

int x = 0;

With this statement, the computer first allocates memory for 6 ("I declare position 42 to hold the value of x!"), and then assigns 0 to that memory location. Now, no matter what was previously held in position 42, the bits are now:

0000 0000

[AnilM823]

Thanks, make sense. But to follow up on this concept:

So for example, let's say we've got a local variable declared as an int (not yet assigned any value to it). So now we have 4 bytes allocated on the stack (on most machines). Actually let's assume it's an unsigned int. So I'm assuming whatever garbage value is in those 4 bytes before initialization must still be constrained to the 2^32 limit for the unsigned int, correct?

[Ganon11]

Correct. This is because, whatever garbage information is there, your computer will still interpret it as an unsigned int, because you told it that it would be an unsigned int. So the 'smallest' possible value is

0000 0000 0000 0000 0000 0000 0000 0000

a.k.a. 0, and the 'largest' possible value is

1111 1111 1111 1111 1111 1111 1111 1111

a.k.a. (2^32)-1.

[AnilM823]

Got it, thanks for the clarification