C Dynamic Memory Allocation - Complete Guide

Introduction to Dynamic Memory Allocation

Dynamic memory allocation allows programs to request memory at runtime rather than compile time. This enables flexible data structures that can grow or shrink as needed, efficient memory usage, and handling of data whose size is unknown at compile time.

malloc() Function - Complete Guide

The malloc() (memory allocation) function allocates a block of memory of specified size in bytes and returns a pointer to the beginning of the block. The allocated memory contains garbage values (uninitialized).

Key Characteristics:

• Uninitialized Memory: Contains garbage values (random data)
• Return Type: void* (generic pointer) - requires casting
• NULL Check: Always check if malloc returns NULL
• Size Calculation: Use sizeof() operator for portability
• Memory Alignment: Returns memory aligned for any data type
• Heap Allocation: Memory comes from heap segment

Memory Lifecycle Visualization:

malloc() Examples:

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

int main(void) {
    int *p = (int *)malloc(sizeof(int));
    if (!p) return 1;
    *p = 42;
    printf("%d\n", *p);
    free(p);
    return 0;
}

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

int main(void) {
    int n = 5, i;
    int *arr = (int *)malloc(n * sizeof(int));
    if (!arr) return 1;
    for (i = 0; i < n; i++) arr[i] = i * 10;
    printf("%d\n", arr[2]);
    free(arr);
    return 0;
}

calloc() Function - Complete Guide

The calloc() (contiguous allocation) function allocates memory for an array of elements, initializes all bytes to zero, and returns a pointer to the memory. It's ideal for arrays and structures that need zero initialization.

Key Characteristics:

• Zero-Initialized: All bits set to zero (0 for integers, 0.0 for floats, NULL for pointers)
• Two Parameters: Takes number of elements and size of each element
• Array-Oriented: Designed for allocating arrays
• Slower than malloc: Extra overhead for zero initialization
• Memory Calculation: Total memory = num × size bytes
• Safer: Zero initialization prevents garbage values

calloc() vs malloc() Comparison:

calloc() Examples:

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

int main(void) {
    int *arr = (int *)calloc(5, sizeof(int));
    if (!arr) return 1;
    arr[0] = 10;
    printf("%d (rest are 0)\n", arr[0]);
    free(arr);
    return 0;
}

realloc() Function - Complete Guide

The realloc() (reallocate) function changes the size of a previously allocated memory block. It can expand or shrink the allocation while preserving existing data (as much as possible).

Key Characteristics:

• Size Change: Can increase or decrease allocation size
• Data Preservation: Preserves existing data up to minimum of old and new size
• Pointer May Change: May return different pointer address
• NULL Pointer: If ptr is NULL, realloc() behaves like malloc()
• Zero Size: If new_size is 0 and ptr is not NULL, memory is freed
• Performance: May need to copy data if can't expand in place

realloc() Behavior Scenarios:

realloc() Examples:

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

int main(void) {
    int *p = (int *)malloc(2 * sizeof(int));
    if (!p) return 1;
    p[0] = 1; p[1] = 2;
    p = (int *)realloc(p, 4 * sizeof(int));
    if (!p) return 1;
    p[2] = 3; p[3] = 4;
    printf("%d %d %d %d\n", p[0], p[1], p[2], p[3]);
    free(p);
    return 0;
}

free() Function - Complete Guide

The free() function deallocates memory previously allocated by malloc(), calloc(), or realloc(). It returns the memory to the heap for reuse. Proper memory deallocation is crucial to prevent memory leaks.

Key Characteristics:

• Memory Deallocation: Returns memory to heap
• No Return Value: Function returns void
• NULL Safe: free(NULL) does nothing (safe to call)
• Dangling Pointers: Pointer becomes invalid after free()
• Memory Leak: Forgetting to free() causes memory leak
• Double Free: Calling free() twice on same pointer causes undefined behavior
• Heap Corruption: Freeing non-heap memory or corrupted pointers

Memory Leak Visualization:

free() Examples:

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

int main(void) {
    int *p = (int *)malloc(sizeof(int));
    if (!p) return 1;
    *p = 99;
    free(p);
    p = NULL;
    printf("freed and set to NULL\n");
    return 0;
}

Common Memory Errors and Solutions

Memory management errors are among the most common and difficult-to-debug issues in C programming. Understanding these errors and their solutions is crucial for writing robust programs.

# Compile: gcc -g program.c -o program
# Run:     valgrind --leak-check=full ./program

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 1;
    free(p);
    return 0;
}