Pointers and dynamic memory

What if we don’t know how much memory will be required to store our data?

It’s possible to determine the amount of memory needed at the execution time and then request this from the operating system. This is called dynamic memory allocation.

Pointers and dynamic memory #include<stdio.h> int total; int square(int a) { return a*a; //a^2 } int squareofsum(int a, int b) int c = square(a+b); return c; //(a+b)^2 int main() int m = 2, n = 4; total = squareofsum(m,n); printf("Square of sum is %d\n",total);   Application's memory Heap function calls, local variables Stack global Static/Global Instructions Code (Text)

Pointers and dynamic memory   Stack Play sq() x Pause sos() a,b,c main() Stack frame m,n Global total #include<stdio.h> int total; int square(int a) { return a*a; //a^2 } int squareofsum(int a, int b) int c = square(a+b); return c; //(a+b)^2 int main() int m = 2, n = 4; total = squareofsum(m,n); printf("Square of sum is %d\n",total);   Application's memory Heap function calls, local variables Stack global Static/Global Instructions Code (Text)

Pointers and dynamic memory   Stack Play sos() a,b,c Pause main() Stack frame m,n Global total #include<stdio.h> int total; int square(int a) { return a*a; //a^2 } int squareofsum(int a, int b) int c = square(a+b); return c; //(a+b)^2 int main() int m = 2, n = 4; total = squareofsum(m,n); printf("Square of sum is %d\n",total);   Application's memory Heap function calls, local variables Stack global Static/Global Instructions Code (Text)

Pointers and dynamic memory   Stack Play main() Stack frame m,n Global total #include<stdio.h> int total; int square(int a) { return a*a; //a^2 } int squareofsum(int a, int b) int c = square(a+b); return c; //(a+b)^2 int main() int m = 2, n = 4; total = squareofsum(m,n); printf("Square of sum is %d\n",total);   Application's memory Heap function calls, local variables Stack global Static/Global Instructions Code (Text)

Pointers and dynamic memory   Stack Play printf() Pause main() Stack frame m,n Global total #include<stdio.h> int total; int square(int a) { return a*a; //a^2 } int squareofsum(int a, int b) int c = square(a+b); return c; //(a+b)^2 int main() int m = 2, n = 4; total = squareofsum(m,n); printf("Square of sum is %d\n",total);   Application's memory Heap function calls, local variables Stack global Static/Global Instructions Code (Text)

Pointers and dynamic memory   Stack Play main() Stack frame m,n Global total #include<stdio.h> int total; int square(int a) { return a*a; //a^2 } int squareofsum(int a, int b) int c = square(a+b); return c; //(a+b)^2 int main() int m = 2, n = 4; total = squareofsum(m,n); printf("Square of sum is %d\n",total);   Application's memory Heap function calls, local variables Stack global Static/Global Instructions Code (Text)

Pointers and dynamic memory   Stack Stack frame Global total #include<stdio.h> int total; int square(int a) { return a*a; //a^2 } int squareofsum(int a, int b) int c = square(a+b); return c; //(a+b)^2 int main() int m = 2, n = 4; total = squareofsum(m,n); printf("Square of sum is %d\n",total);   Application's memory Heap function calls, local variables Stack global Static/Global Instructions Code (Text)

Pointers and dynamic memory   Stack Stack frame Global #include<stdio.h> int total; int square(int a) { return a*a; //a^2 } int squareofsum(int a, int b) int c = square(a+b); return c; //(a+b)^2 int main() int m = 2, n = 4; total = squareofsum(m,n); printf("Square of sum is %d\n",total);   Application's memory Heap function calls, local variables Stack global Static/Global Instructions Code (Text)

Pointers and dynamic memory   Stack (1 MB)  D()  Stack overflow C() B() Stack frame A() Global #include<stdio.h> int total; int square(int a) { return a*a; //a^2 } int squareofsum(int a, int b) int c = square(a+b); return c; //(a+b)^2 int main() int m = 2, n = 4; total = squareofsum(m,n); printf("Square of sum is %d\n",total);   Application's memory Heap function calls, local variables Stack global Static/Global Instructions Code (Text)

Pointers and dynamic memory   Stack Stack frame Global #include<stdio.h> int total; int square(int a) { return a*a; //a^2 } int squareofsum(int a, int b) int c = square(a+b); return c; //(a+b)^2 int main() int m = 2, n = 4; total = squareofsum(m,n); printf("Square of sum is %d\n",total);   Application's memory  Free store Heap function calls, local variables Stack global Static/Global Instructions Code (Text)

Pointers and dynamic memory   Stack Stack frame Global Heap -- Not heap date structure   To access heap – malloc() calloac() realloc() free()   Application's memory Heap function calls, local variables Stack global Static/Global Instructions Code (Text)

Pointers and dynamic memory   Application's memory Heap function calls, local variables Stack global Static/Global Instructions Code (Text) #include<stdio.h> #include<stdlib.h> int main() { int x; //will be stored in the stack int *p; p = (int*)malloc(sizeof(int)); *p = 10; *p = 20; } Stack Heap   20 800 main() p = 400 800 10 400 x

Pointers and dynamic memory   Application's memory Heap function calls, local variables Stack global Static/Global Instructions Code (Text) #include<stdio.h> #include<stdlib.h> int main() { int x; //will be stored in the stack int *p; p = (int*)malloc(sizeof(int)); *p = 10; free(p); *p = 20; } Stack Heap   20 800 main() p = 400 800 400 x

Pointers and dynamic memory   Application's memory Heap function calls, local variables Stack global Static/Global Instructions Code (Text) #include<stdio.h> #include<stdlib.h> int main() { int x; //will be stored in the stack int *p; p = (int*)malloc(sizeof(int)); *p = 10; free(p); p = (int*)malloc(10*sizeof(int)); *p = 20; } Stack Heap   200 main() p = 200 240 x p[0], p[1], p[2] *p, *(p+1), *(p+2)

Dynamic memory allocation - Pros No need to decide how much memory to allocate when writing the program, giving us more flexibility. Free up memory for other programs after it is no longer used by the program which allocates it.

Dynamic memory allocation - Cons Have to use pointers. The programmer has the responsibility of tracking the locations of allocated memory and freeing it up. It’s possible to create a memory leak, i.e., memory that is no longer used is not freed. If the process is repeated, the amount of unfreed memory grows in size.

Example 1 int i, *d; d = (int *) malloc( 5 * sizeof(int) ); for(i = 0; i < 5; i++) d[i] = i + 100;