C++/Memory management in C++
I have following questions in C++
1.What is Stack and heap ? What is the use (2 separate) of it?
2.When i declare a global object where it is kept? Stack or heap? How compiler knows about that? Only with new operator?
1.What is Stack and heap ? What is the use (2 separate) of it?
The stack and heap are two separate memory areas used for data storage in main memory in a C++ program.
Stack storage is automatically managed by the code and is used for data local to a function call - note I say function call not function. Note that C/C++ call this automatic storage. The stack works by allocating a new block of storage for each function call and relinquishing this storage on function return. Processors usually have support for managing stack data - usually in the form of specific registers to point to current stack top (and maybe a base pointer to the whole stack frame for a function call) and instructions to push and pop data on and off of the stack.
The stack is so named because of the data structure it uses - a stack or LIFO (last in first out).
Stacks are allocated on a per thread of execution basis and are fundamental to most if not all implementations of threads, tasks and other types of units of execution.Operating systems often have a separate kernel mode stack they use internally.
Although the operation of the stack has dynamic properties the compiler has enough information to calculate what storage is required by each function call, and so has static properties as well. Hence I suppose the term automatic rather than dynamic to prevent confusion with fully dynamic storage.
A heap on the other hand is an area where the programmer has to manually manage allocation and deallocation of storage by making specific allocation and deallocation requests (new and delete in C++) and is used for dynamic storage (i.e. storage requested at runtime). The memory used by a heap is usually obtained directly from the operating system, although C/C++ runtime libraries may try to improve performance by requesting big blocks from the operating system and dividing them up for small allocations. The heap is sometimes called the free store in C and C++.
Note that heap is also a data structure. However whether a free store is really implemented as a heap structure is an implementation issue.
2.When i declare a global object where it is kept? Stack or heap?
Such data is stored in the static storage area. Static storage is fixed for the whole program duration. The compiler and linker have enough information to calculate the required storage requirements at program build time and this is mapped into memory at program load time - often directly from the executable file. Hence static objects exist for the whole duration of the program - although those requiring complex (i.e. dynamic) initialisation will not be initialised until some specific point in the program execution. Simple static initialisation (e.g. initialising a static int to some value such as 123) can be done at build time and this value just copied from the executable file into memory at program startup.
2a/ How compiler knows about that? Only with new operator?
i) In a function definition static storage is requested using the static keyword. Otherwise an object has automatic (stack) storage. Unlike local automatic objects, local static objects' state survives across function calls but a local static object cannot be accessed outside of the function (or smaller) scope in which it is defined.
ii) Outside of any function definition _any_ object definition defines an object having static storage.
If such a definition is prefixed with the static keyword then it is private to the source file in which it is defined (or more accurately to the translation unit in which it is defined. A translation unit is approximately what is compiled by the compiler proper after preprocessing). Such private static objects are only visible to code following their definition until the end of the file. Such private static objects are said to have internal linkage.
If such a definition is not prefixed with the static keyword then it has external linkage and is visible as a symbol to the linker, and therefore to other source files (translation units). Such objects _must_ obey the one definition rule across the whole program and not just within the source code file (translation unit) in which they are defined. Only _one_ translation unit can define (i.e. cause storage to be reserved for) an external static object. All other uses must use a declaration by using the extern keyword before the type and name of the global object.
So to summarise:
C and C++ have three types of storage:
1/ Static storage for function-local and internal and external global objects that have storage allocated for the whole of the program duration. Complex static objects requiring dynamic initialisation may not be fully initialised (created) until some later point (if at all) in a programs execution - but once fully created they exist until destroyed during program termination.
2/ Automatic storage on the stack. Such objects apply only to objects defined locally to a function. They exist until the function returns or for a shorter time if they have a smaller scope within the function. Automatic storage is the default storage class for local function objects.
Stacks are allocated on a per unit of execution basis.
3/ Dynamic storage on the free store or heap is managed at runtime (i.e. dynamically) via explicit calls or operators - e.g. new and delete. Objects allocated from the free store exist until explicitly released (freed, deleted, deallocated, etc...).
4/ The terms static and dynamic when used in the context of C++ programs often mean "at compile / link time" (static) and "at run time" (dynamic).
5/ A function or object (variable) definition reserves storage for that entity. A declaration merely states that such an entity exists. Such entities can only be _defined_ once in a program. However they can be declared to exist as many times as required. A function declaration is sometimes called a function prototype (from C). Most definitions in C and C++ are also declarations. Only global objects with external linkage can have declarations in C and C++, all other such statements are definitions (and declarations).
extern int GlobalInt; // declaration of a static 'global' object defined elsewhere
int GlobalInt = 12; // definition of a static 'global' object having external linkage
static int PrivateStatic = 10; // definition of a static 'global' object having internal linkage
void SomeFunction // function declaration or prototype; function defined elsewhere
( int n
, long & value
void SomeFunction // function definition:
( int n
, long & value // arguments are stack based having automatic storage
if ( 0==n ) // n for this call different from n of other calls
static int callDepth(0); // Define static local variable. Only created once.
// State (value) of callDepth survives across function calls.
std::cout << "At call depth: "
long newValue = value * n; // Define automatic object stored on function call stack frame
SomeFunction( n-1, newValue ); // Recursive function call, gets a new stack frame
value = newValue;
} // n, value, newValue for this call destroyed here;
// callDepth static so continues to exist with its current state
long * pValue = new long; // Dynamically create a new long object on the free store at
// runtime and return a pointer to it. Note the created object
// is default constructed in this case, which for built in types
// equates to being uninitialised.
*pValue = 1;
std::cout << "Result of SomeFunction(10, 1) is " << *pValue << std::endl;
delete pValue; // Objects dynamically created exist until explicitly deleted.
// Note in this case we could probably get away with forgetting
// to delete the object pointed to by pValue as the next
// operation is to terminate the program execution and most
// modern desktop and server operating systems will be able to
// release all such process resources. However this is not true
// in the general case even for dynamically allocated objects
// that should be deleted as here just before program
// termination. Some resources held by such objects (of user
// defined types) may not be automatically released on program
// termination and some execution environments (e.g. embedded
// environments) may not do clean up for us.
// Static objects notionally destroyed here: after or during
// return from main but before program termination.
// This includes PrivateStatic, GlobalInt and callDepth
Hope this is of use and please ask further questions to clarify anything you do not understand as trying to take all this in at once could be a bit overwhelming and I do not know what you do or do not know already. Hopefully this will at least act as a starting point for your enlightenment of this subject and something we can both refer to if you require further help.