Dynamic Memory Allocation

# CHAPTER 14

Dynamic Memory Allocation #

1. Introduction #

2. Learning Objectives #

• Understand the difference between the Stack and the Heap.

• Use malloc() and calloc() to request memory.

• Use realloc() to resize memory.

• Use free() to prevent memory leaks.

• Build a dynamically sized application.

3. Stack vs. Heap Memory #

• Stack: Fast, auto-managed memory where local variables and arrays live. It is small (a few megabytes).

• Heap: Large pool of memory used for dynamic allocation. You (the programmer) must manually request and release memory here.

4. The <stdlib.h> Library #

#### 1. malloc() - Memory Allocation Requests a single block of memory of a specific size. It returns a void pointer to the first byte, which you cast to your desired type. It does NOT initialize the memory (contains garbage values).

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    // Request memory for 5 integers
    ptr = (int*) malloc(5 * sizeof(int)); 
    
    if (ptr == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }
    
    ptr[0] = 10; // Use it just like an array!
    printf("%d\n", ptr[0]);
    
    free(ptr); // ALWAYS free memory when done!
    return 0;
}

#### 2. calloc() - Contiguous Allocation Similar to malloc, but it takes two arguments (number of elements, size of element) and initializes all bits to zero.

int *ptr;
// Allocate 5 integers and set them all to 0
ptr = (int*) calloc(5, sizeof(int)); 

#### 3. realloc() - Re-allocation Resizes a previously allocated memory block. Useful if your array gets full and you need more space.

// Resize ptr to hold 10 integers instead of 5
ptr = (int*) realloc(ptr, 10 * sizeof(int));

#### 4. free() - Releasing Memory C has no Garbage Collector. If you malloc memory, it stays reserved until the program ends. If you do this in a loop, you will use all available RAM (a Memory Leak). You must call free().

free(ptr);
ptr = NULL; // Good practice: prevent Dangling Pointers

5. Mini Project: Dynamic Student Records #

#include <stdio.h>
#include <stdlib.h>

int main() {
    int n, i;
    int *marks;
    int sum = 0;

    printf("Enter number of students: ");
    scanf("%d", &n);

    // Dynamically allocate memory
    marks = (int*) malloc(n * sizeof(int));

    if (marks == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // Get input
    for (i = 0; i < n; i++) {
        printf("Enter marks for student %d: ", i + 1);
        scanf("%d", &marks[i]);
        sum += marks[i];
    }

    printf("Average marks: %.2f\n", (float)sum / n);

    // Free memory
    free(marks);
    printf("Memory freed successfully.\n");

    return 0;
}

6. Visualizing the Heap #

int *ptr = malloc(3 * sizeof(int));

Stack:               Heap (Dynamically Allocated):
+----------+         +--------+--------+--------+
| ptr      | ------> | Garbage| Garbage| Garbage|
| (0x100)  |         | (0x500)| (0x504)| (0x508)|
+----------+         +--------+--------+--------+

7. Common Mistakes #

• Memory Leaks: Forgetting to call free().

• Dangling Pointers: Using a pointer *after* it has been freed. (Always set it to NULL after freeing).

• Not checking for NULL: If the computer is out of memory, malloc returns NULL. If you try to use it, the program crashes.

• Buffer Overrun on Heap: Allocating 5 ints, but writing to ptr[10]. This corrupts the heap.

8. Exercises #

1. 1. Write a program using calloc to allocate memory for 5 floats, print them to prove they are 0, then free them.

1. 2. Write a program that allocates 3 ints, fills them, uses realloc to expand to 5 ints, fills the rest, and prints all 5.

9. MCQ Quiz with Answers #

10. Interview Questions #

• Q: Explain the difference between Stack and Heap memory.

• Q: What is a memory leak, and how does it happen in C?

• Q: Why does malloc take a sizeof operator instead of just a number?

11. Summary #

12. Next Chapter Recommendation #