Disclaimer: This presentation is prepared by
trainees of baabtra as a part of mentoring
program. This is not official document of baabtra
Baabtra-Mentoring Partner is the mentoring division of baabte System
Technologies Pvt . Ltd
Stack is a special region of computer's memory that stores temporary
variables created by each function (including the main() function).The stack is a
"FILO" (first in, last out) data structure, that is managed and optimized by the
CPU quite closely. Every time a function declares a new variable, it is "pushed"
onto the stack.Then every time a function exits, all of the variables pushed
onto the stack by that function, are freed (that is to say, they are deleted).
Once a stack variable is freed, that region of memory becomes available for
other stack variables.
the stack grows and shrinks as functions push and pop local
there is no need to manage the memory yourself, variables
are allocated and freed automatically
the stack has size limits
stack variables only exist while the function that created
them, is running
c=sum(a , b);
int sum(int a , int b)
The heap is a region of computer's memory that is not
managed automatically , and is not as tightly managed by
the CPU. It is a more region of memory .
To allocate memory on the heap, you must
use malloc() or calloc(), which are built-in C functions.
Once you have allocated memory on the heap, you are
responsible for using free() to deallocate that memory
once you don't need it any more. If you fail to do this, your
program will have what is known as a memory leak.That
is, memory on the heap will still be set aside (and won't be
available to other processes).
malloc() Allocates requested size of bytes and
returns a pointer first byte of allocated space
calloc() Allocates space for an array
elements, initializes to zero and then returns a
pointer to memory
free() deallocate the previously allocated
realloc() Change the size of previously
malloc(size in bytes);
This function allocates ‘size’ byte of memory and returns a pointer to
the first byte or NULL if there is some kind of error
But we need a pointer to point to the allocated space in heap
int *p; p=malloc(2);
p=malloc(2); //allocates 2 bytes of memory
p=malloc(sizeof(int)); //sizeof() returns size of any data type
so here it will be malloc(2)
p=(int *)malloc(2); //malloc always return void * pointer .
So you may type cast it into
any data type.
but it is unnecessary as the compiler
p=(int *)malloc (sizeof(int)); //allocates 2 bytes of memory
Calloc() stands for "contiguous allocation”
Allocates multiple blocks of memory each of same size and sets all
bytes to zero
calloc(number of elements , size in bytes);
we need a pointer to point to the allocated space in heap
p=calloc(2,2); //allocates 2 block of 2 bytes memory
p=calloc(3,sizeof(int)); //sizeof() returns size of any data type
so here it will be calloc(3,2)
p=(int *)calloc(2,10); //calloc always return void * pointer .
So you may type cast it into any data type.
but it is unnecessary as the compiler does it
p=(int *)calloc (3,sizeof(int)); //allocates 3 block of 2 bytes
• Allocates "size" bytes of memory.
• The contents of
allocated memory are not
changed. i.e., the memory may
contains garbage values.
• returns void pointer (void *). If
the allocation succeeds, a pointer
to the block of memory is returned
a region of memory large
enough to hold "n elements" of
"size" bytes each.
• The allocated region is
initialized to zero.
• returns void pointer (void *). If
the allocation succeeds, a
pointer to the block of
memory is returned.
realloc( pointer name , new size );
It will realloc the size of memory
free( pointer name );
De allocate the memory