1. Recall
• What are functions used for?
• What happens when we declare a
varaible? Say int a;
• What is the difference between array and
structure?
• What is the output if i print *p, p, &p ?

2. Introduction to C
Memory Management
Week 3- day 1

3. When does memory
allocated in C?
• There are two ways in which memory can
be allocated in C:
–by declaring variables
–by explicitly requesting space from C
• Each case above space is allocated at
different sectors of RAM

4. Where does memory
allocated in C?
–by declaring variables -
Stack
–by explicitly requesting space from C
- Heap

5. Stack

6. Stack
• Stack is the place where all the
variables that are declared and
initialized before runtime are stored.
• Stack follows Last in First Out
order(LIFO)
• When the program finishes stack will
release all the spaces allocated for
variables.
Stack
12
32
322
34

7. main()
{
Int a=10,b=20,c;
c=sum(a,b);
}
int sum(int a,int b)
{
int c;
c=a+b;
return c;
}
RAM
Main()
a=10
b=20
c =30
sum()
a =10
b=20
C=30

8. What if there is no enough stack
space?
Stack
Main()
Aaa()
Bbb()
Ccc()
Ddd()
Eee()
Fff()Stack Over flow

9. Heap

10. Heap
• Heap is the area of memory used for
dynamic memory allocation
• Programmer allocates memory manually
at heap ; and hence variable on the heap
must be destroyed manually. There is no
automatic release as in stack23 32
43
452
89

11. How to allocate space in heap?
• C inbuilt functions
–Malloc() Allocates the
specified number of bytes
–Calloc() Allocates the
specified number of bytes
and initializes them to zero
–Realloc() Increases or decreases
the size of the specified
block of memory.
Reallocates it if needed

12. Malloc()
• malloc() stands for "memory allocation"
• The malloc() function dynamically
allocates memory when required.
• This function allocates „size‟ byte of
memory and returns a pointer to the first
byte or NULL if there is some kind of error
Syntax
malloc(size_in_bytes);

13. Malloc()
• Int *p;
• P=malloc(2);
HEAP
2 byte memory
Stack
1000
1000

14. All are same !
int *p;
p=malloc(2); //allocates 2 bytes of
memory
p=malloc(sizeof(Int)); //sizeof() returns
size of any data type
so here it will be mallloc(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

15. #include <stdio.h>
#include <stdlib.h>
void main()
{
int n,i,*ptr,sum=0;
printf("Enter number of elements: ");
scanf("%d",&n);
ptr=(int*)malloc(n*sizeof(int)); //memory allocated using malloc
if(ptr==NULL)
{ printf("Error! memory not allocated."); exit(0); }
Printf(“Enter the elements of Array”);
For(i=0;i<n;++i)
{
Scanf(“%d”,ptr+i);
Sum+=*(ptr+i);
}
Printf(“sum=%d”,sum);
free(ptr); // allocated memory is released
}
HEAPStack
n=10
1000ptr=1000

16. calloc()
• Calloc() stands for "contiguous allocation”
• Allocates multiple blocks of memory each of
same size and sets all bytes to zero
• Syntax
calloc(number_of_elements,size_in_byt
es);
Again we need a pointer to point to the
allocated space in heap

17. calloc()
• Int *p;
• P=calloc(3,10);
HEAP
10 bytes size
Stack
1000
1000
10 bytes size
10 bytes size
1001
1010

18. #include <stdio.h>
#include <stdlib.h>
void main()
{
int n,i,*ptr,sum=0;
printf("Enter number of elements: ");
scanf("%d",&n);
ptr=(int*)calloc(n,sizeof(int)); //memory allocated using calloc
if(ptr==NULL)
{ printf("Error! memory not allocated."); exit(0); }
Printf(“Enter the elements of Array”);
For(i=0;i<n;++i)
{
Scanf(“%d”,ptr+i); // Scanf(“%d”,&ptr[i]);
Sum+=*(ptr+i);
}
Printf(“sum=%d”,sum);
free(ptr); // allocated memory is released
}

19. Malloc() Vs Calloc()
• 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.
• Allocates
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.

20. Structure of Ram

21. Structure of Ram
TEXT
Also known as the code segment,
holds the executable instructions
of a program.
• execute-only
• fixed size

22. Structure of Ram
A global variable that is initialized
and stored in the data segment.
This section has read/write
attributes but cannot be shared
among processes running the
same program.

23. Structure of Ram
This section holds uninitialized
data. This data consists of global
variables that the system
initializes with 0s upon program
execution. Another name for this
section is the zero-initialized data
section.

24. Structure of Ram
When a program uses malloc() to
obtain dynamic memory, this
memory is placed in the heap.

25. Structure of Ram
This contains all the local
variables that get allocated.
When a function is called, the
local variables for that function
are pushed onto the stack.

26. Questions?
“A good question deserve a good
grade…”

27. Self Check !!

28. Self Check
• When the program execution ends
variables in heap will be automatically
released
–True
–False

29. Self Check
• When the program execution ends
variables in heap will be automatically
released
–True
–False

30. Self Check
• Reference to the heap memory will be
stored in
•Heap
•Stack
•Gvar
•BSS

31. Self Check
• Reference to the heap memory will be
stored in
•Heap
•Stack
•Gvar
•BSS

32. Self Check
• Difference between malloc() and
calloc()
•Number of arguments
•No of blocks
•Initialization
•All of above
•None of above

33. Self Check
• Difference between malloc() and
calloc()
•Number of arguments
•No of blocks
•Initialization
•All of above
•None of above

34. Self Check
• Complete the below
Main()
{
int n,i,*ptr,sum=0;
printf("Enter number of elements: ");
scanf("%d",&n);
ptr=(int*) malloc (n*sizeof(int));
}

35. Self Check
• Complete the below
Main()
{
int n,i,*ptr,sum=0;
printf("Enter number of elements: ");
scanf("%d",&n);
ptr=(int*) malloc (n*sizeof(int));
}

36. Self Check
Free()
Malloc()
Heap
Callloc()
Stack
Variables
2 arguments
Automatically free the
memory
Automatically allocated
in stack
Reserves one block of
memory
Should be used when

37. Self Check
Free()
Malloc()
Heap
Callloc()
Stack
Variables
2 arguments
Automatically free the
memory
Automatically allocated
in stack
Reserves one block of
memory
Should be used when

38. main()
{
int i,a[10];
for(i=0;i<10;i++)
{
printf(“Enter the
number”);
scanf(“%d”,&a[i]);
}
main()
{
int i,*p,n;
printf(“Enter the number of
elements”);
scanf(“%d”,&n);
*p=calloc(n,sizeof(int));
for(i=0;i<10;i++)
{
printf(“Enter the
number”);
scanf(“%d”,&p [i]);
Self Check

39. main()
{
int i,a[10];
for(i=0;i<10;i++)
{
printf(“Enter the
number”);
scanf(“%d”,&a[i]);
}
main()
{
int i,*p,n;
printf(“Enter the number of
elements”);
scanf(“%d”,&n);
*p=calloc(n,sizeof(int));
for(i=0;i<10;i++)
{
printf(“Enter the
number”);
scanf(“%d”,&p [i]);
Self Check

40. End of Day 1