Lesson 09-C Language Dynamic Memory Management

Dynamic memory management is one of the core capabilities of the C language, allowing programs to dynamically allocate and release memory at runtime to flexibly handle data of uncertain size. However, improper use can lead to issues such as memory leaks, fragmentation, and access errors. This article provides a comprehensive analysis from dynamic memory allocation functions, memory leak detection, memory pools, thread safety, memory alignment, memory fragmentation, custom memory management, to dynamic arrays vs linked lists, combined with code examples and best practices, to help developers master the core skills of dynamic memory management.

Dynamic Memory Allocation Functions: malloc/calloc/realloc/free

The C language implements dynamic memory allocation through standard library functions, with the core functions being malloc, calloc, realloc, and free.

malloc: Allocate a memory block of specified size

malloc is used to allocate a contiguous block of memory. Its prototype is as follows:

#include <stdlib.h>

void* malloc(size_t size);
  • Parameters: size is the number of bytes to allocate.
  • Return value: On success, returns a pointer to the memory block (void* type, which can be cast to any type); on failure, returns NULL.

Example: Allocating an integer array

int n = 5;
int* arr = (int*)malloc(n * sizeof(int));  // Allocate space for 5 ints
if (arr == NULL) {
    perror("malloc failed");
    exit(EXIT_FAILURE);
}
// Use the memory
for (int i = 0; i < n; i++) {
    arr[i] = i * 10;
}
free(arr);  // Release memory (critical!)

calloc: Allocate and initialize a memory block

calloc is similar to malloc but initializes the memory to zero, making it suitable for scenarios requiring zeroed memory (e.g., arrays of structures). Its prototype is:

void* calloc(size_t nmemb, size_t size);
  • Parameters: nmemb is the number of elements, size is the size of each element (total size is nmemb * size).
  • Return value: On success, returns a pointer to the zero-initialized memory block; on failure, returns NULL.

Example: Allocating and initializing a structure array

typedef struct {
    int id;
    char name[20];
} Student;

int n = 3;
Student* students = (Student*)calloc(n, sizeof(Student));  // Allocate 3 Students, initialized to 0
if (students == NULL) {
    perror("calloc failed");
    exit(EXIT_FAILURE);
}
// Use the memory (no need to manually zero)
students[0].id = 1;
strcpy(students[0].name, "Zhang San");
free(students);

realloc: Resize an already allocated memory block

realloc is used to adjust the size of an already allocated memory block (expand or shrink). Its prototype is:

void* realloc(void* ptr, size_t new_size);
  • Parameters: ptr is the memory pointer returned by malloc/calloc (if NULL, equivalent to malloc(new_size)); new_size is the new memory block size.
  • Return value: On success, returns a pointer to the new memory block (which may differ from the original pointer); on failure, returns NULL (original memory block remains unchanged).

Example: Dynamically expanding an array

int* arr = (int*)malloc(2 * sizeof(int));  // Initially allocate 2 ints
if (arr == NULL) exit(EXIT_FAILURE);

// Expand to 5 ints
int* new_arr = (int*)realloc(arr, 5 * sizeof(int));
if (new_arr == NULL) {
    perror("realloc failed");
    free(arr);  // Original memory still valid, must free manually
    exit(EXIT_FAILURE);
}
arr = new_arr;  // Update pointer

// Use the expanded memory
for (int i = 0; i < 5; i++) {
    arr[i] = i;
}
free(arr);

Notes:

  • realloc may move the memory block (if there is not enough space after the original block), so the return value must be used to receive the new pointer.
  • If new_size is 0 and ptr is not null, realloc is equivalent to free(ptr) and returns NULL.

free: Release dynamically allocated memory

free is used to release memory allocated by malloc/calloc/realloc. Its prototype is:

void free(void* ptr);
  • Parameters: ptr is the memory pointer to release (if NULL, free does nothing).
  • Note: After release, the pointer becomes a dangling pointer; it should be manually set to NULL to avoid misuse.

Example: Properly releasing memory

int* arr = (int*)malloc(3 * sizeof(int));
if (arr == NULL) exit(EXIT_FAILURE);

// Use memory...

free(arr);
arr = NULL;  // Critical! Avoid dangling pointer

Memory Leak Detection: Causes and Tools

Causes of Memory Leaks

A memory leak occurs when allocated memory is not released, causing available memory to gradually decrease, potentially leading to program crashes. Common causes include:

  • Forgetting to call free to release memory.
  • Overwriting a dynamically allocated memory pointer (e.g., ptr = realloc(ptr, new_size) without freeing the original memory).
  • Improper synchronization of memory release operations in multithreading.

Memory Leak Detection Tools

  • Valgrind: A classic tool for Linux/macOS, used via valgrind --leak-check=full ./program to detect leaks.
  • AddressSanitizer (ASan): Built into GCC/Clang, enabled by compiling with -fsanitize=address.
  • Windows Debugging Tools: Such as Visual Studio’s “Diagnostic Tools” window.

Example: Valgrind detecting a leak

// leak.c
#include <stdlib.h>

int main() {
    int* ptr = (int*)malloc(sizeof(int));
    // No free(ptr)
    return 0;
}

Compile and run:

gcc leak.c -o leak
valgrind --leak-check=full ./leak

The output will indicate the exact location of the memory leak:

==12345== 4 bytes in 1 blocks are definitely lost in loss record 1 of 1
==12345==    at 0x483B7F3: malloc (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==12345==    by 0x109189: main (leak.c:4)

Memory Pool: Pre-allocation and Reuse

Role of Memory Pools

A memory pool is a strategy that pre-allocates a large block of memory and divides it as needed, reducing the overhead of frequent malloc/free calls (system call time cost) and mitigating memory fragmentation. Commonly used in high-performance scenarios (e.g., game engines, network frameworks).

Memory Pool Implementation Example

Below is a simple memory pool implementation (fixed-size blocks):

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

#define POOL_SIZE 1024  // Total pool size (bytes)
#define BLOCK_SIZE 32   // Size of each block (bytes)
#define NUM_BLOCKS (POOL_SIZE / BLOCK_SIZE)  // Total number of blocks

typedef struct {
    bool used[NUM_BLOCKS];  // Mark whether a block is in use
    char data[POOL_SIZE];   // Actual memory space
} MemoryPool;

// Initialize memory pool
void pool_init(MemoryPool* pool) {
    memset(pool->used, false, sizeof(pool->used));
}

// Allocate a block
void* pool_alloc(MemoryPool* pool) {
    for (int i = 0; i < NUM_BLOCKS; i++) {
        if (!pool->used[i]) {
            pool->used[i] = true;
            return &pool->data[i * BLOCK_SIZE];  // Return block start address
        }
    }
    return NULL;  // Pool is full
}

// Free a block
void pool_free(MemoryPool* pool, void* ptr) {
    if (ptr < pool->data || ptr >= pool->data + POOL_SIZE) return;  // Invalid pointer
    int index = ((char*)ptr - pool->data) / BLOCK_SIZE;
    pool->used[index] = false;
}

int main() {
    MemoryPool pool;
    pool_init(&pool);

    // Allocate blocks
    void* block1 = pool_alloc(&pool);
    void* block2 = pool_alloc(&pool);
    if (block1 && block2) {
        printf("Allocation successful: block1=%p, block2=%p\n", block1, block2);
    }

    // Free blocks
    pool_free(&pool, block1);
    pool_free(&pool, block2);

    return 0;
}

Advantages:

  • Reduces system call frequency, improving performance.
  • Avoids memory fragmentation (fixed-size blocks).

Disadvantages:

  • Pre-allocated memory may be wasted (if actual usage is much less than pool size).
  • Must handle block alignment (ensure block start addresses meet data type requirements).

Thread-Safe Dynamic Memory Management

Memory Issues in Multithreading

In multithreaded programs, multiple threads calling malloc/free simultaneously may cause race conditions, such as:

  • Thread A allocating memory while Thread B frees the same block.
  • Concurrent modification of the allocator’s internal data structures (e.g., free block list), leading to crashes.

Thread-Safe Implementation Methods

  • Mutex Locks: Lock memory allocation/release operations to ensure only one thread operates at a time.
  • Thread-Local Storage (TLS): Allocate independent memory pools per thread to avoid shared resource contention.

Example: Using mutex to protect memory allocation

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

static pthread_mutex_t malloc_mutex = PTHREAD_MUTEX_INITIALIZER;

// Thread-safe malloc
void* thread_safe_malloc(size_t size) {
    pthread_mutex_lock(&malloc_mutex);
    void* ptr = malloc(size);
    pthread_mutex_unlock(&malloc_mutex);
    return ptr;
}

// Thread-safe free
void thread_safe_free(void* ptr) {
    pthread_mutex_lock(&malloc_mutex);
    free(ptr);
    pthread_mutex_unlock(&malloc_mutex);
}

// Test thread function
void* thread_func(void* arg) {
    int* num = (int*)thread_safe_malloc(sizeof(int));
    *num = 100;
    printf("Thread %ld allocated memory: %d\n", (long)pthread_self(), *num);
    thread_safe_free(num);
    return NULL;
}

int main() {
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, thread_func, NULL);
    pthread_create(&tid2, NULL, thread_func, NULL);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

Notes:

  • Mutex locks introduce performance overhead; lock granularity must be balanced (e.g., lock per memory pool instead of global lock).
  • TLS is suitable for thread-independent operations (e.g., each thread has its own object pool), but resource cleanup on thread exit must be handled.

Memory Alignment

Concept of Memory Alignment

Memory alignment means that the starting address of data in memory must be a multiple of its size (e.g., int occupies 4 bytes, so the starting address must be a multiple of 4). Modern CPUs access aligned data faster; unaligned access may cause performance degradation (or even hardware errors, e.g., on ARM).

Alignment Rules

  • Basic type alignment requirements: Equal to their size (e.g., char 1 byte, short 2 bytes, int 4 bytes, double 8 bytes).
  • Structure alignment requirements: Equal to the alignment of the member with the largest alignment requirement.
  • Compiler directives: Use #pragma pack(n) to adjust structure alignment granularity (n is the maximum alignment value).

Example: Structure alignment

#include <stdio.h>
#include <stddef.h>  // For offsetof macro

// Structure without specified alignment
struct Unaligned {
    char c;   // 1 byte (align 1)
    int i;    // 4 bytes (align 4) → needs 3 bytes padding (1+3=4)
    short s;  // 2 bytes (align 2) → no padding (4+2=6, total structure size 8? depends on max alignment)
};  // Total size: 1(c) + 3(padding) + 4(i) + 2(s) + 2(padding) = 12 bytes?

// Structure with 4-byte alignment specified
#pragma pack(push, 4)
struct Aligned4 {
    char c;   // 1 byte (align 1)
    int i;    // 4 bytes (align 4) → 3 bytes padding (1+3=4)
    short s;  // 2 bytes (align 2) → no padding (4+2=6, total structure size 8?)
};  // Total size: 8 bytes (max alignment 4)
#pragma pack(pop)

int main() {
    printf("Unaligned structure size: %zu\n", sizeof(struct Unaligned));  // Output 12
    printf("Aligned4 structure size: %zu\n", sizeof(struct Aligned4));    // Output 8
    printf("Offset of i in Unaligned: %zu\n", offsetof(struct Unaligned, i));  // Output 4 (1+3)
    return 0;
}

Notes:

  • Alignment is handled automatically by the compiler; manual intervention is usually unnecessary.
  • Data with high alignment requirements (e.g., double) should be allocated separately to avoid mixing with other data in memory pools.

Memory Fragmentation

Causes of Memory Fragmentation

Memory fragmentation occurs when frequent allocation and release of small memory blocks result in available memory being split into non-contiguous small blocks. There are two types:

  • External fragmentation: Free memory blocks are scattered in different locations and cannot be merged into large blocks.
  • Internal fragmentation: Unused portions within allocated memory blocks (e.g., malloc(5) allocates 8 bytes, wasting 3 bytes).

Methods to Mitigate Memory Fragmentation

  • Memory pools: Pre-allocate large blocks and divide into fixed sizes to reduce fragmentation.
  • Merging free blocks: Allocators (e.g., dlmalloc) merge adjacent free blocks upon release.
  • Avoid frequent small allocations/releases: Reuse allocated memory (e.g., object pools).

Example: Memory pool reducing fragmentation

By pre-allocating a large block and allocating in fixed sizes (as in the earlier memory pool example), external fragmentation is avoided because all blocks are the same size and can be reused after release.

Custom Memory Management

Need for Custom Memory Management

The standard library’s malloc/free may not meet specific scenario requirements (e.g., performance optimization, memory tracking, specific alignment). Custom memory management can achieve:

  • Memory pools: Pre-allocate and reuse memory blocks.
  • Debugging features: Log allocation/release, detect leaks.
  • Specific alignment: Ensure memory blocks are allocated with specified alignment.

Custom Memory Allocator Example

Below is a simple debugging memory allocator (records allocation location and size):

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

#define DEBUG 1

typedef struct {
    void* ptr;          // Actual allocated memory pointer
    size_t size;        // Allocated size
    const char* file;   // File where allocation occurred
    int line;           // Line where allocation occurred
} AllocInfo;

static AllocInfo* alloc_list = NULL;  // Record all allocated memory blocks
static size_t list_size = 0;

// Custom malloc
void* debug_malloc(size_t size, const char* file, int line) {
    void* ptr = malloc(size + sizeof(AllocInfo));  // Extra space for debug info
    if (ptr == NULL) {
        perror("malloc failed");
        exit(EXIT_FAILURE);
    }

    // Record debug info
    AllocInfo* info = (AllocInfo*)ptr;
    info->ptr = ptr;
    info->size = size;
    info->file = file;
    info->line = line;

    // Add info to list (simplified example, real implementation needs linked list or dynamic array)
    alloc_list = realloc(alloc_list, (list_size + 1) * sizeof(AllocInfo));
    alloc_list[list_size++] = *info;

    return (void*)(info + 1);  // Return start address of user-available memory
}

// Custom free
void debug_free(void* ptr) {
    if (ptr == NULL) return;
    AllocInfo* info = (AllocInfo*)ptr - 1;  // Find debug info
    free(info->ptr);  // Free actual memory
    // Remove from list (simplified example, real implementation needs traversal)
    for (size_t i = 0; i < list_size; i++) {
        if (&alloc_list[i] == info) {
            memmove(&alloc_list[i], &alloc_list[i+1], (list_size - i - 1) * sizeof(AllocInfo));
            list_size--;
            break;
        }
    }
}

// Example usage
#define malloc(s) debug_malloc(s, __FILE__, __LINE__)
#define free(p) debug_free(p)

int main() {
    int* arr = (int*)malloc(5 * sizeof(int));
    free(arr);
    return 0;
}

Output debug information (add logging function):

// Add logging in debug_free
printf("Freeing memory: %p (from %s:%d, size %zu bytes)\n", 
       info->ptr, info->file, info->line, info->size);

Dynamic Arrays vs Linked Lists: Selection and Comparison

Dynamic Array

A dynamic array is an array stored in contiguous memory that supports dynamic resizing (via realloc).

Features:

  • Memory layout: Contiguous, cache-friendly (CPU cache prefetch efficient).
  • Access speed: O(1) (direct index access).
  • Insert/delete: Tail insert O(1) (amortized, realloc may be O(n)), middle insert/delete O(n) (element shifting).
  • Applicable scenarios: Random access, data size changes little or mainly tail operations (e.g., logging).

Example: Dynamic array implementation

typedef struct {
    int* data;
    size_t size;      // Current number of elements
    size_t capacity;  // Array capacity (allocated memory size / element size)
} DynamicArray;

// Initialize dynamic array
void da_init(DynamicArray* da, size_t initial_capacity) {
    da->data = (int*)malloc(initial_capacity * sizeof(int));
    da->size = 0;
    da->capacity = initial_capacity;
}

// Add element (tail insert)
void da_push_back(DynamicArray* da, int value) {
    if (da->size == da->capacity) {
        size_t new_capacity = da->capacity * 2;  // Double capacity
        int* new_data = (int*)realloc(da->data, new_capacity * sizeof(int));
        if (new_data == NULL) {
            perror("realloc failed");
            exit(EXIT_FAILURE);
        }
        da->data = new_data;
        da->capacity = new_capacity;
    }
    da->data[da->size++] = value;
}

// Free memory
void da_free(DynamicArray* da) {
    free(da->data);
    da->data = NULL;
    da->size = da->capacity = 0;
}

Linked List

A linked list is a non-contiguous memory linear structure connected by pointers.

Features:

  • Memory layout: Non-contiguous, cache-unfriendly (nodes may be scattered).
  • Access speed: O(n) (requires node traversal).
  • Insert/delete: O(1) at known position (pointer adjustment), no element shifting.
  • Applicable scenarios: Frequent insert/delete, uncertain data size, or no random access needed (e.g., task queues).

Example: Singly linked list implementation

typedef struct Node {
    int data;
    struct Node* next;
} Node;

typedef struct {
    Node* head;
    size_t size;
} LinkedList;

// Initialize linked list
void ll_init(LinkedList* ll) {
    ll->head = NULL;
    ll->size = 0;
}

// Head insertion
void ll_push_front(LinkedList* ll, int value) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->data = value;
    new_node->next = ll->head;
    ll->head = new_node;
    ll->size++;
}

// Free memory
void ll_free(LinkedList* ll) {
    Node* current = ll->head;
    while (current != NULL) {
        Node* temp = current;
        current = current->next;
        free(temp);
    }
    ll->head = NULL;
    ll->size = 0;
}

Choose Dynamic Array or Linked List?

FeatureDynamic ArrayLinked List
Memory ContiguityContiguousNon-contiguous
Random AccessO(1) (efficient)O(n) (inefficient)
Insert/Delete (middle)O(n) (shift elements)O(1) (adjust pointers)
Insert/Delete (tail)O(1) (amortized)O(1) (with tail pointer optimization)
Memory UtilizationHigh (no extra pointer overhead)Low (each node needs extra pointer)
Cache FriendlinessHigh (contiguous memory easy to prefetch)Low (nodes scattered)
Applicable ScenariosRandom access frequent, tail operations frequentFrequent insert/delete, no random access needed

Summary and Practice

Key Summary

  • Dynamic memory allocation: malloc/calloc/realloc are core functions; always check return values and free memory.
  • Memory leaks: Use tools (Valgrind, ASan) to detect; avoid forgetting to free or pointer overwriting.
  • Memory pools: Pre-allocate large blocks, reduce system calls and fragmentation, suitable for high-frequency allocation.
  • Thread safety: Protect shared memory operations with mutex or TLS.
  • Memory alignment: Follow compiler rules to avoid performance issues from unaligned access.
  • Memory fragmentation: Mitigate with memory pools or free block merging.
  • Custom memory management: Implement debugging, performance optimization, or specific alignment allocators as needed.
  • Dynamic array vs linked list: Choose based on access pattern (random/sequential) and insert/delete frequency.

Practice

  • Release promptly: Plan release timing immediately after allocation to avoid dangling pointers.
  • Minimize allocations: Combine small allocations into large blocks to reduce malloc calls.
  • Use tools: Use Valgrind/ASan during development to detect leaks and out-of-bounds access.
  • Avoid over-engineering: Prefer standard library functions; customize memory management only when necessary.

By mastering this knowledge, developers can efficiently manage dynamic memory in C, writing robust and high-performance programs.

Course: Mastering C Programming From Basics to Advanced Techniques
Share your love

Trending now

Exploring Web 3D Core Technologies Development
Assembly Language Programming From Low-Level Logic to System Kernel
WebRTC Advanced Guide：Media, Transport & Architecture
WebSocket Deep Guide：Building High-Performance Realtime Systems