Dynamic memory allocation for data structure DS3a.pdf

Memory of a Program
Memory
assigned to
a program
Whenever a program
executes, the operating
system allocates some space
in memory for it.

Memory of a Program
Heap
Stack
Static/Global
Code Instructions
Global variables
Function calls
& Local variables
The memory allocated to a
program is divided into four
parts.

Memory of a Program
Heap
Stack
Static/Global
Code
#include<stdio.h>
int total;
int Square(int x)
{
return(x*x);
}
int SquareOfSum(int x,int y)
{
int z = Square(x+y);
return(z);
}
int main()
{
int a=4, b=8;
total = SquareOfSum(a,b);
printf(“Output=%d”,total);
}

Use of Stack
#include<stdio.h>
int total;
int Square(int x)
{
return(x*x);
}
{
return(z);
}
int main()
{
int a=4, b=8;
}
Heap
Stack
Static/
Global
Code

Use of Stack
#include<stdio.h>
int total;
int Square(int x)
{
return(x*x);
}
{
return(z);
}
int main()
{
int a=4, b=8;
}
Heap
Stack
Static/
Global
Code
total

Use of Stack
#include<stdio.h>
int total;
int Square(int x)
{
return(x*x);
}
{
return(z);
}
int main()
{
int a=4, b=8;
}
Heap
Stack
Static/
Global
Code
total
main()
a, b
Stack frame for
main() function

Use of Stack
#include<stdio.h>
int total;
int Square(int x)
{
return(x*x);
}
{
return(z);
}
int main()
{
int a=4, b=8;
}
Heap
Stack
Static/
Global
Code
total
main()
a, b

Use of Stack
#include<stdio.h>
int total;
int Square(int x)
{
return(x*x);
}
{
return(z);
}
int main()
{
int a=4, b=8;
}
Heap
Stack
Static/
Global
Code
total
main()
a, b
SquareOfSum()
x, y, z

Use of Stack
#include<stdio.h>
int total;
int Square(int x)
{
return(x*x);
}
{
return(z);
}
int main()
{
int a=4, b=8;
}
Heap
Stack
Static/
Global
Code
total
main()
a, b
SquareOfSum()
x, y, z
Square()
x

Use of Stack
#include<stdio.h>
int total;
int Square(int x)
{
return(x*x);
}
{
return(z);
}
int main()
{
int a=4, b=8;
}
Heap
Stack
Static/
Global
Code
total
main()
a, b
printf()

Use of Stack
#include<stdio.h>
int total;
int Square(int x)
{
return(x*x);
}
{
return(z);
}
int main()
{
int a=4, b=8;
}
Heap
Stack
Static/
Global
Code
LIFO – Last In First Out

Limitation of Stack
#include<stdio.h>
int total;
int Square(int x)
{
return(x*x);
}
{
return(z);
}
int main()
{
int a=4, b=8;
}
Heap
Stack
Static/
Global
Code
Stack Overflow
FuncA()
FuncB()
FuncC()
FuncD()

Limitation of Stack
• Allocation and deallocation of stack memory are handled by
Operating System. Programmer cannot control the lifetime of variables
in stack memory.
• Allocation: Function starts (Push onto stack)
• Deallocation: Function finishes (Popped out of stack)
• Size of the stack frame for a function is known at the compile time.
• An array with unknown size (only known at run time) cannot be
allocated in the stack memory.
• For this, we need to use heap memory.

Heap Memory
• A programmer can define the size of an array at run time
using dynamic memory allocation.
• All variables/array defined using dynamic memory allocation
are allocated memory from heap.
• The programmer can decide how long the allocated memory
to be kept.
• Heap can grow as long as the program does not run out of the
memory allocated to it.
– Sometimes dangerous if proper care is not taken.
• Heap is called a free pool/store of memory

Use of Heap
(Dynamic Memory Allocation)
Dynamic Memory Allocation
C language
• malloc() – Allocates block of memory
• calloc() – Allocate multiple blocks and
initialize to 0.
• realloc() – Reallocates block of
memory
• free() – Frees up memory
C++ language
• new – Allocates block of memory
• delete – Frees up memory
Heap
Stack
Static/
Global
Code

Use of Heap
C language (Example code)
#include<stdio.h>
#include<stdlib.h>
Heap
Stack
Static/
Global
Code

Use of Heap
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a=10;
Heap
Stack
Static/
Global
Code
main()
a 10

Use of Heap
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a=10;
int *p;
p = (int*)malloc(sizeof(int));
Heap
Stack
Static/
Global
Code
main()
a 10
p 200
? 200

Use of Heap
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a=10;
int *p;
*p=15;
Heap
Stack
Static/
Global
Code
main()
a 10
p 200
15 200

Use of Heap
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a=10;
int *p;
*p=15;
p=(int*)malloc(sizeof(int));
*p=20;
Heap
Stack
Static/
Global
Code
main()
a 10
p 100
15 200
20 100
Memory
Leak

Use of Heap
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a=10;
int *p;
*p=15;
free(p);
p=(int*)malloc(sizeof(int));
*p=20;
}
Heap
Stack
Static/
Global
Code
main()
a 10
p 100
200
20 100

Use of Heap
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a=10;
int *p;
p = (int*)malloc(4*sizeof(int));
p[0]=10;
p[1]=20;
*(p+2)=30;
*(p+3)=40;
}
Heap
Stack
Static/
Global
Code
main()
a 10
p 150
10 150
20
30
40

Use of Heap
C++ language (Example code)
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a=10;
int *p;
p = new int;
*p=10;
Heap
Stack
Static/
Global
Code
main()
a 10
p 200
10 200

Use of Heap
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a=10;
int *p;
p = new int;
*p=10;
delete p;
Heap
Stack
Static/
Global
Code
main()
a 10
200

Use of Heap
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a=10;
int *p;
p = new int;
*p=10;
delete p;
p = new int[4];
for(int i=0;i<4;i++)
p[i]=0;
Heap
Stack
Static/
Global
Code
main()
a 10
50
p 50
0
0
0
0

Use of Heap
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a=10;
int *p;
p = new int;
*p=10;
delete p;
p = new int[4];
for(int i=0;i<4;i++)
p[i]=0;
delete[ ] p;
}
Heap
Stack
Static/
Global
Code
main()
a 10
50

Dynamic 2D Array Allocation in C
Using single pointer

main()
arr 200
200
Space for
r x c
elements
(i,j)th Element: *(arr+i*c+j) or arr[i*c+j]
Stack
Heap
2D array mapped into 1D array in memory

Using array of pointers

main()
arr 300
100
Space for c
elements of
0th row
(i,j)th Element: arr[i][j]
300
600
Space for c
elements of
0th row
Space for c
elements of
0th row
arr[2] 100
arr[1] 800
arr[0] 600
800
Stack
Heap

Freeing Dynamic 2D Array in C
• For single pointer:
main()
arr 200
200
Space for
r x c
elements
Stack
Heap

• For single pointer:
free(arr);
main()
200
Stack
Heap

• For array of pointers
main()
arr 300
100
Space for c
elements of
0th row
300
600
Space for c
elements of
0th row
Space for c
elements of
0th row
arr[2] 100
arr[1] 800
arr[0] 600
800
Stack
Heap

for(i=0;i<r;i++){
free(arr[i]);}
main()
arr 300
100
300
600
800
Stack
Heap

for(i=0;i<r;i++){
free(arr[i]);}
free(arr);
main()
100
300
600
800
Stack
Heap

Dynamic 2D Array Allocation and Freeing in C++
int r=3, c=4;
int** arr = new int[r*c];
(i,j)th element can be accessed by *(arr + i*c+j) or arr[i*c+j]
For freeing memory:
delete[] arr;

Dynamic 2D Array Allocation and Freeing in C++
Using array of pointers
int r=3, c=4;
int** arr = new int*[r];
for(i=0;i<r;i++)
arr[i] = new int[c];
(i,j)th element can be accessed by arr[i][j];
For freeing memory:
for(i=0;i<r;i++){
delete[] arr[i]);}
delete[] arr;
arr
arr[0]
arr[1]
arr[2]

Limitations of Dynamic Array
200
201
202
Heap Memory

Heap Memory (Horizontal View)
200
201
202

• Memory Manager (A part of operating systems)
manages the memory.
• Keeps track of free space
• Allocates space on request from the programs
200
201
202

200
201
202
Consider a program segment:
int *p=(int*)malloc(3*sizeof(int));

200
201
202
212
p
int *p=(int*)malloc(3*sizeof(int)); // int size is 4 bytes

200
201
202
212
p
float *q=(float*)malloc(sizeof(float)); // float size is 8 bytes

200
201
202
212
p
213
220
q

200
201
202
212
p
int *r=(int*)malloc(4*sizeof(int)); // int size is 4 bytes
213
220
q

200
201
202
212
p
213
220
q
221
236
r

200
201
202
212
p
free(q)
213
220
q
221
236
r

200
201
202
212
p
free(q)
213
220
221
236
r

200
201
202
212
p
free(q)
int *s=(int*)malloc(3*sizeof(int)); // int size is 4 bytes
Although free memory is more than required 3 x 4 = 12 bytes, yet it
cannot be allocated as it is not contiguous. Returns a null pointer.
213
220
221
236
r

Solution: Linked List
200
201
202
212
Suppose we need to store a list of 4 integers: 7, 10, 5, 9.
Instead of asking memory manager for an integer array of 4 elements,
these 4 integers can be stored one at a time in memory in different
places.
213
220
221
236

7
200
201
202
212
int *p=(int*)malloc(sizeof(int)); *p=7;
213
220
221
236
p

10
7
200
201
202
212
int *q=(int*)malloc(sizeof(int)); *q=10;
213
222
236
p q

5 10
7
200
201
202
212
int *r=(int*)malloc(sizeof(int)); *r=5;
213
222
236
p q
r

9
5 10
7
200
201
202
212
int *r=(int*)malloc(sizeof(int)); *r=5;
int *s=(int*)malloc(sizeof(int)); *s=9;
Non-contiguous allocation: Hence it is not possible to traverse the list
directly as done in array.
213
222
233
p q
r s

9
5 10
7
200
201
202
212
To traverse the elements of the list, one should store the address of the
next element in the list with each element.
213
222
233
p q
r s

-1
213
233
222 9
5 10
7
202
To traverse the elements of the list {7, 10, 5, 9}, one should store the
address of the next element (pointer to next element) in the list with
each element.
It is sufficient to know the address of (pointer to) the first node (also
called as head node) to retrieve all the elements of the list.
The last node points to null (represented by -1 here).
213
222
233
p

Logical View of Linked List
7 10 5 9
Head
Structure of each node
struct node
{
int val;
struct node* next;
}

Dynamic memory allocation for data structure DS3a.pdf

More Related Content

Similar to Dynamic memory allocation for data structure DS3a.pdf (20)

Recently uploaded (20)

Dynamic memory allocation for data structure DS3a.pdf