Local variables popped from stack or is it ?

Code:

void main()
{
  int * j = fun();

   printf("%d", *j); 
}

int * fun()
{
  int k = 35;

   return &k;
}

The value 35 is printed in main. However, I expected a garbage value to be printed since k would be popped off the stack once the function fun() returns.

If I precede the printf statement by some other function call, *j prints out the wrong value implying that the stack contents changed & therefore the wrong value. Does that imply that k remained on stack all this while ?

Can anyone explain exactly how this is working ?

Perhaps you should examine the assembly output. Note that this is undefined behaviour that you are observing.

Originally Posted by laserlight

Perhaps you should examine the assembly output. Note that this is undefined behaviour that you are observing.

To be honest, I don't know how to do that but I will give it a try...but you do agree then that the output should be garbage ?

It is undefined because the memory you are trying to access is no longer reserved by your variable so it could be overwritten. For most languages and I believe C as well (anyone correct me if I am wrong) local variables are stored on the call stack along with other information such as the return address and function paramaters. So from main if you called your fun() your call stack would look like:

Code:

                                       ________________
                                      |                         
                                      | local  variables    
                                      _________________  
                                      |                         
                                      | return address     
                                       ________________
                                      |                         
                                      | parameters to fun
                                      _________________

Once your fun() returns control to main this memory is no longer allocated by the call stack to your fun(). Thus in your first example you still recieved the value but only because nothing else happened to need that memory. Now when you called some other function the call stack was again used and, in the case you saw overwrote the memory you were pointing to by j.

As Laser said this is undefined because depending on the function calls and order you tried to access the memory that specific address may or may not be used again in the call stack.

A short answer - the variable doesn't exist once the function returns because it goes out of scope and is no longer reserved in the call stack.

The memory location formerly known as k will continue to exist after the function has returned.

The exact moment at which that location gets re-used for something else is totally out of your control. All you're seeing at the moment is an element of pure dumb luck.

Scope is a high level language concept. When something goes out of scope (say a local variable on the return of a function), what disappears is your right to guaranteed access to that variable. The underlying memory used to store that variable almost certainly persists, but it will be re-used again and again.

Originally Posted by trish

To be honest, I don't know how to do that but I will give it a try...but you do agree then that the output should be garbage ?

As far as we should be concerned it is garbage. It's garbage that happened to be the value 35 when you examined it.
It could just as easily have been intentionally overwritten by a compiler that tries to catch users writing code the has undefined behaviour. But generally a value in memory is left as it was until something else uses it, only because it isn't worth spending time overwriting memory with a differnt value when nothing is going to look at it. Had you called any other function in the mean time you'd probably find that the value was different.

Originally Posted by trish

Code:

void main()
{
  int * j = fun();

   printf("%d", *j); 
}

int * fun()
{
  int k = 35;

   return &k;
}

The value 35 is printed in main. However, I expected a garbage value to be printed since k would be popped off the stack once the function fun() returns.

If I precede the printf statement by some other function call, *j prints out the wrong value implying that the stack contents changed & therefore the wrong value. Does that imply that k remained on stack all this while ?

Can anyone explain exactly how this is working ?

Dumb luck... because nothing else has overwritten that stack location yet.

Popping a variable does not reset it to 0... it merely abandons that slot on the stack.
The same is true with free() ... it doesn't reset memory, it merely abandons it.

In a more complex program it would fail.

See what happens when you print *j a second time right after the first. There is a good chance the first call to printf will use that memory space and the second printf will print "garbage".
So even if it still holds your old data in that printf, good chance even in the next call it will be gone.

Dylan