Thread: Stack Problem

Hello guys.This is my first post.

Problem: The first printf outputs 35 which makes sense but the second printf outputs a garbage value? I know this has something to do with stack but can any1 clarify how it works in this program?Thanks.

Code:

int *j;

j=fun( );

printf("\n %d ",*j);

printf("\n %d ",*j);

int *fun( )
{

int k=35;

return (&k);

}

I am using Turbo C++ and i dont see any warning.

but if it gets destroyed than why does the first printf display 35 ,which means thats the value of 35 is still in stack but after the first printf the variable k gets destroyed. I am confused in the working of the stack cant seem to understand it clearly

Originally Posted by Waleed Mujeeb

but if it gets destroyed than why does the first printf display 35 ,which means thats the value of 35 is still in stack but after the first printf the variable k gets destroyed. I am confused in the working of the stack cant seem to understand it clearly

It might not explicitly be destroyed, more like abandoned, which means that the value can be overwritten by something else, which you just witnessed yourself. The take home point here is that you should make no assumptions about this value, because you can't.

On the same line, I know when a function exits, the local variables are deallocated the hence returning their addresses are meaningless. In case you want to save the address, use the declaration static int k = 35 instead of int k = 35. This saves the address of k even after exiting the function.

But I do have a question about allocating the memory within the function. when u allocate a memory dynamically in a function, what happens to it when u exit the function? does it get deallocated or is it saved until free( ) is called somewhere else in the program? and if it is saved until free is called somewhere else, the argument to free, which is a pointer is local to the function where memory was allocated. Can this pointer be accessed from some other part of the program? In other words, what is the scope of a pointer which is dynamically initiated?

Thanks,
Livin

Originally Posted by livin

In other words, what is the scope of a pointer which is dynamically initiated?

Thanks,
Livin

The pointer will also be destroyed, but the address it contains will be valid until that region is freed. When you return from such a function you could return the value (i.e the address on the heap) but not the pointer it self.

Code:

char *foo() {
     char *p = malloc( 16 * sizeof(char) );
     if(!p) return NULL;
     
     return p;
}

Originally Posted by Subsonics

... When you return from such a function you could return the value (i.e the address on the heap) but not the pointer it self.

Isn't returning the value viz. the heap location, the same thing as returning the pointer itself.

Originally Posted by Subsonics

Well p in this case, is a local variable. What I had in mind was the difference of returning the value that p contains and returning &p like Waleed Mujeeb did in the first post.

Yep! the address of a local variable would be a dangling pointer; and thanks for clarifying.

Originally Posted by Subsonics

The pointer will also be destroyed, but the address it contains will be valid until that region is freed. When you return from such a function you could return the value (i.e the address on the heap) but not the pointer it self.

In that case, if the pointer is destroyed, how will you free the memory that it points to? shouldn't u have a statement like free(p) somewhere before main() exits? and if p is no longer available what argument would free() take?

Originally Posted by Tibo-88

In order to free the memory, you need a pointer to the address of that memory. So you always need to keep a valid pointer to a dynamically allocated memory, otherwise, this memory will be "definitely lost", which means that the program will not be able to reuse the memory, since it will still be considered as allocated, even though you cannot access it anymore.


Yes you should, but not necessarily "p", since as mentioned previously, the p variable will not be valid anymore once you leave the function. For example, using the "foo" function that Subsonics posted, you could do like :

Code:

char *p2 = foo();
//do whatever you want with that pointer, and when not needed anymore :
free(p2);

Ahah! got it. thanks for the clarification.