1. 1 Dynamic Memory Allocation –The need –malloc/free –Memory Leaks –Dangling Pointers and Garbage Collection Today’s Material

2. 2 C’s data structures have fixed size known at compile time –char – 1 byte –short – 2 bytes –int – 4 bytes –float – 4 bytes –double – 8 bytes –Array size must be known at compile time and is fixed int A[10]; –Structure and Union sizes are also fixed Often the actual size of an array is not known until the execution time! Dynamic Memory Allocation: Why?

3. 3 Consider a simple program that takes some number of integers and performs some operation on them The question that arises is the size of the array that will store the integers Dynamic Memory Allocation: Why?

4. 4 The usual approach is to declare an array that is as big as it ever will need to be –#define N 1000000 /* at most 1 million numbers */ –int A[N]; Adv: Simple Disadvantages –Even if we manipulate only 100 numbers, we still reserve space for 1 million integers, but use only the first 100, wasting the rest –Cannot handle input larger than 1 million Solution –Dynamically allocate as much space as needed during execution Dynamic Memory Allocation: Why?

5. 5 C library provides 2 functions that perform dynamic memory allocation and de-allocation Dynamic Memory Allocation Functions void *malloc(int size); /* Allocates size many bytes of contiguous memory * and return a pointer to the beginning of the * memory chunk. * Returns NULL if the memory cannot be allocated */ void free(void *pointer); /* Deallocates memory previously allocated by malloc * pointed to by pointer */

6. 6 Example (1) char *p = NULL; p = (char *)malloc(50); if (p == NULL){ printf(“Out of memory\n”); exit(1); } /* end-if */ p[0] = ‘a’; p[1] = ‘b’; p[2] = ‘\0’; printf(“p= \n”, p); /* Will print p= */ 50 bytes long p p points to a 50 byte long contiguous memory chunk How you use this memory is application dependant

7. 7 Example (2) char *pi = NULL; /* Allocate space for 25 integers */ pi = (int *)malloc(sizeof(int)*25); pi[0] = 5; pi[1] = 2; free(pi); /* Deallocate space */ What if we want to allocate space for say 25 integers?

8. 8 Memory Leaks It is your responsibility to deallocate memory chunks when you are done with them If you forget to deallocate the space, it will still be part of your address space, but you cannot access it –This is called a memory leak

9. 9 Memory Leaks: Example /* Allocate space for 10 ints */ pi = malloc(10*sizeof(int)); pi[0] = 2;.. /* Allocate space for 20 ints without deallocating * space for the previous 10 ints */ pi = malloc(20*sizeof(int)); pi[0] = 3; /* Notice that we lost the handle to the previous * memory chunk. That space has leaked out of the * program. If your program runs long enough, * leaking memory like this continuously, it * will be out of memory. */

10. 10 Dangling Pointer Problem char *p, *q; p = (char *)malloc(10); q = p; p[0] = ‘A’; q[1] = ‘B’;.. free(p); q[0] = ‘X’; /* Wrong! */ It is illegal to use memory that has been freed Consider the following program 10 bytes long p q At this point the memory chunk pointed to by either p or q is invalid. It has been freed and cannot be accessed P & q are called dangling pointers

11. 11 Dangling Pointers (cont) To avoid memory leaks and dangling pointers, programming languages such as Java, C# handle dynamic memory deallocation automatically –This is called garbage collection –The runtime environment of Java and C# has automatic garbage collectors –Thus programmers do not have to deallocate memory The disadvantage of this approach is speed –Java, C# is slower compared to C, C++ –safety  versus  speed tradeoff