Dynamic Memory Allocation

[kwzeet]

Hi,
I have declared a global variable as pointer. The program performs certain number of iterations. After every iteration, the size of memory required for the pointer changes and this pointer variable is to be accessed by different functions. Now, here is my doubt:
If I allocate the memory for this global variable in a function, will the contents of the memory be lost once I exit that function. In my opinion, it should not be the case as the dynamic memory allocation takes place in "heap" and should not be affected by the call of functions. Am I right??
Thanks.

[JohnGraham]

If I allocate the memory for this global variable in a function, will the contents of the memory be lost once I exit that function.

No, it will not be lost - the memory remain valid until either (i) you call free() on the pointer that malloc() passed out to you or (ii) your program exits.

[Cat]

Also note, it's not "because" of being on the heap that memory allocated with malloc() remains allocated until you call free().

C, in fact, doesn't define 'stack' versus 'heap' variables - or even require that a stack or a heap exist. It defines 'automatic' allocation versus 'dynamic' allocation (and the third being 'static' allocation). Stacks and heaps are implementation details - automatic/dynamic/static describe how the variables behave, which is all the standard specifies. How that behavior is implemented is something that you shouldn't need to know or care about. If you allocate the storage to be pointed at dynamically (e.g. via malloc), then it will persist until you free it. If you allocate the storage space automatically, it will persist until the automatic variable goes out of scope.

Now, yes, automatic allocation is usually implemented as a stack, because it simply makes a lot of sense to do it that way - the properties of a stack allow the behavior of an automatic variable to be simply and efficiently implemented. Note, though, that even in implementations where most automatic variables end up on a stack, some might not - for example, some implementations may store C99 variable length arrays on the heap, but they must still behave as automatic variables - that is, they will be deallocated when they go out of scope.

There's an important and often glossed-over distinction between the behavior and the implementation of that behavior. The behavior is guaranteed by standards, but the implementation is flexible.

[Adak]

I gave your reply above, a "like", but truth is, it's a beautiful reply, Cat!

Well done.

[rcgldr]

Note that alloca() allocates from what is usually the stack, but I haven't seen it used other than some old examples of code.