Stack is a portion of memory that works on the
principle of LIFO (last in first out). It means that last in data will
come out first. In stack two operations are performed. First is PUSH and
another is POP. PUSH function is used to save the data in stack memory and POP
operation is performed to retrieve the data. In stack memory there is a pointer
variable which monitor the top of the stack location in memory. When a
byte is pushed on to the stack this pointer value is increases by one to the
next available address. When a byte is popped from the stack, this pointer
contained value is decremented by one.
Uses of Stack
When a function is
called stack memory is used to temporary store the local variables and return
address from the function. On function call, current program counter (PC) value
(stores the next instruction to be executed) and status register values are
pushed on to the stack.
All the variables
declared in to the function are managed in to the stack. This is the advantage
of stack that we don required to allocate memory for the variable initialized
in to the function. All the variables initialized in the functions are local to
that function.
When program exists from
the function all the variable popped from the stack and stack memory is
cleared. We don’t require clearing this memory. When exist from the function
stored status register and PC values are also popped to start execution after
the function call.
In stack memory there is
a limit of stack memory dependent on operating system. So we can store limited
variables on to stack.
Heap Memory
Heap is the type of memory which is
not managed automatically as stack memory is managed by the CPU. It is a free
memory and there is no limit like stack memory. To allocate and deallocate
memory in heap malloc() and calloc() and free() functions are used. Once the memory is allocated for the
variables in heap it does not clear after exit form functions until we use free() function to clear the memory. When
we use heap memory instead of Stack memory to store variables, these variables
can be accessed globally.
Accessing the heap memory is slower
as compare to access stack memory because we access the heap memory pointers.
Memory management is required in
heap memory. We have to free the memory
location if it not used. If you are not able to free the memory using free() function memory leak problem may
occurred.
Heap memory support dynamic memory
allocation. It means we can resize the variables using realloc() functions.
malloc() Function
malloc() function allocate specified size memory location
for an object and returns a pointer to it. Syntax of malloc() is as follows:
void *malloc(size_t size)
Example:
int *ptr1 = malloc(15);
This will allocate 15 memory location
and return a pointer to ptr1.
calloc()
Function
calloc() function is also used to allocate the
specified memory location for an object and returns a pointer to it. Syntax of
calloc() is as follows:
void
*calloc(size_t
n, size_t siz)
in put argument in calloc() is two variables
one n, that defines the no of location to be reserved and siz will define the
size of each location. The main difference between malloc() an calloc() is that
it will initialized all location to Zero.
Example:
int
*ptr2 = calloc(10,size(int));
realloc()
Function
realloc() function used to resize the
allocated area for an object and return a pointer according to new relocated
memory location. Syntax of calloc() is as follows:
void * realloc (void * ptr, size_t size);
First argument define the address of
firstly allocated memory and second argument is the modified size.
Example:
int *p1
= calloc (5, sizeof (int));
int * p2 = (inrealloc (p1, sizeof(int));
int * p2 = (inrealloc (p1, sizeof(int));
What
is Stack over Flow?
Stack has limited memory location.
It can store a limited amount of memory location. Stack overflow occurs when
try to push larger data from stack memory limitation. When we try to push more
data on stack data will start over flowing in the memory and allocating in the
other portion of memory location. This will cause the crash of system. To
prevent from stack over flow don’t use many nested functions. Not initialize
much of variable locally in any function, if it is required to initialize lot
of variable then use heap to initialize the variable.
