Question

Yesterday I had an interview where the interviewer asked me about the storage classes where variables are stored.

My answer war:

Local Variables are stored in Stack.       
Register variables are stored in Register
Global & static variables are stored in data segment.  
The memory created dynamically are stored in Heap.

The next question he asked me was: why are they getting stored in those specific memory area? Why is the Local variable not getting stored in register (though I need an auto variable getting used very frequently in my program)? Or why global or static variables are not getting stored in stack?

Then I was clueless. Please help me.

Answer 1

The C language does not define where any variables are stored, actually. It does, however, define three storage classes: static, automatic, and dynamic.

Static variables are created during program initialization (prior to main()) and remain in existence until program termination. File-scope (‘global’) and static variables fall under the category. While these commonly are stored in the data segment, the C standard does not require this to be the case, and in some cases (eg, C interpreters) they may be stored in other locations, such as the heap.

Automatic variables are local variables declared in a function body. They are created when or before program flow reaches their declaration, and destroyed when they go out of scope; new instances of these variables are created for recursive function invocations. A stack is a convenient way to implement these variables, but again, it is not required. You could implement automatics in the heap as well, if you chose, and they’re commonly placed in registers as well. In many cases, an automatic variable will move between the stack and heap during its lifetime.

Note that the register annotation for automatic variables is a hint – the compiler is not obligated to do anything with it, and indeed many modern compilers ignore it completely.

Finally, dynamic objects (there is no such thing as a dynamic variable in C) refer to values created explicitly using malloc, calloc or other similar allocation functions. They come into existence when explicitly created, and are destroyed when explicitly freed. A heap is a convenient place to put these – or rather, one defines a heap based on the ability to do this style of allocation. But again, the compiler implementation is free to do whatever it wants. If the compiler can perform static analysis to determine the lifetime of a dynamic object, it might be able to move it to the data segment or stack (however, few C compilers do this sort of ‘escape analysis’).

The key takeaway here is that the C language standard only defines how long a given value is in existence for. And a minimum bound for this lifetime at that – it may remain longer than is required. Exactly how to place this in memory is a subject in which the language and library implementation is given significant freedom.