PrologiCode
Progress: 14 of 16 topics87%

Dynamic Memory Allocation in C Programming

Dynamic memory allocation is a powerful feature in C that allows programs to request memory at runtime rather than at compile time. This enables more flexible and efficient memory usage, as programs can allocate exactly the amount of memory they need based on user input or other runtime conditions.

What You'll Learn

  • Understanding static vs. dynamic memory allocation
  • Using malloc(), calloc(), and realloc() functions
  • Properly freeing allocated memory with free()
  • Creating dynamic arrays and data structures
  • Memory management best practices
  • Avoiding common memory-related errors
  • Practical examples and applications

Memory Types in C Programs

Before diving into dynamic memory allocation, it's important to understand the different types of memory available in a C program:

Stack Memory

  • Used for local variables and function calls
  • Allocated and deallocated automatically
  • Size is fixed at compile time
  • Fast allocation and deallocation
  • Limited in size (typically a few MB)

Heap Memory

  • Used for dynamic memory allocation
  • Managed manually by the programmer
  • Size can be determined at runtime
  • Slower allocation and deallocation
  • Much larger capacity (limited by system memory)

Memory Layout in C Programs

Text Segment (Code)
Initialized Data
Uninitialized Data (BSS)
Heap ↓ (grows downward)
Stack ↑ (grows upward)

• Dynamic memory allocation uses the heap region

• The heap grows downward as more memory is allocated

• The stack grows upward as functions are called

Static vs. Dynamic Memory Allocation

Static Allocation

c
1// Static allocation - size fixed at compile time
2int staticArray[100];  // Always allocates 400 bytes (100 ints)
  • Size must be known at compile time
  • Memory allocated on the stack
  • Automatically deallocated when out of scope
  • Can lead to wasted memory or insufficient space

Dynamic Allocation

c
1// Dynamic allocation - size determined at runtime
2int size = getUserInput();
3int *dynamicArray = malloc(size * sizeof(int));
4// Use the array
5free(dynamicArray);  // Manual deallocation
  • Size can be determined at runtime
  • Memory allocated on the heap
  • Must be manually deallocated
  • Allows for more efficient memory usage

Memory Allocation Functions

C provides several functions for dynamic memory allocation, all defined in the <stdlib.h> header:

malloc() - Memory Allocation

The malloc() function allocates a specified number of bytes from the heap and returns a pointer to the first byte.

c
1#include <stdio.h>
2#include <stdlib.h>
3

4int main() {
5    // Allocate memory for a single integer
6    int *ptr = (int*)malloc(sizeof(int));
7    
8    if (ptr == NULL) {
9        printf("Memory allocation failed!\n");
10        return 1;
11    }
12    
13    // Assign a value to the allocated memory
14    *ptr = 42;
15    
16    printf("Value: %d\n", *ptr);
17    
18    // Free the allocated memory
19    free(ptr);
20    
21    return 0;
22}
23

24// Output:
25// Value: 42

malloc() Syntax

void* malloc(size_t size);
  • size: Number of bytes to allocate
  • Return value: Pointer to the allocated memory, or NULL if allocation fails
  • Memory is not initialized (contains garbage values)
  • Typically used with sizeof operator: malloc(n * sizeof(type))

calloc() - Contiguous Allocation

The calloc() function allocates memory for an array of elements, initializing all bytes to zero.

c
1#include <stdio.h>
2#include <stdlib.h>
3

4int main() {
5    // Allocate memory for an array of 5 integers
6    int *arr = (int*)calloc(5, sizeof(int));
7    
8    if (arr == NULL) {
9        printf("Memory allocation failed!\n");
10        return 1;
11    }
12    
13    // Print the values (all should be 0)
14    printf("Values after calloc: ");
15    for (int i = 0; i < 5; i++) {
16        printf("%d ", arr[i]);
17    }
18    printf("\n");
19    
20    // Assign values to the array
21    for (int i = 0; i < 5; i++) {
22        arr[i] = (i + 1) * 10;
23    }
24    
25    // Print the new values
26    printf("Values after assignment: ");
27    for (int i = 0; i < 5; i++) {
28        printf("%d ", arr[i]);
29    }
30    printf("\n");
31    
32    // Free the allocated memory
33    free(arr);
34    
35    return 0;
36}
37

38// Output:
39// Values after calloc: 0 0 0 0 0
40// Values after assignment: 10 20 30 40 50

calloc() Syntax

void* calloc(size_t num_elements, size_t element_size);
  • num_elements: Number of elements to allocate
  • element_size: Size of each element in bytes
  • Return value: Pointer to the allocated memory, or NULL if allocation fails
  • Memory is initialized to zero
  • Equivalent to malloc(num_elements * element_size) followed by setting all bytes to zero

realloc() - Memory Reallocation

The realloc() function changes the size of a previously allocated memory block. It can make the block larger or smaller.

c
1#include <stdio.h>
2#include <stdlib.h>
3

4int main() {
5    // Initial allocation for 5 integers
6    int *arr = (int*)malloc(5 * sizeof(int));
7    
8    if (arr == NULL) {
9        printf("Memory allocation failed!\n");
10        return 1;
11    }
12    
13    // Initialize the array
14    for (int i = 0; i < 5; i++) {
15        arr[i] = (i + 1) * 10;
16    }
17    
18    // Print the initial array
19    printf("Initial array: ");
20    for (int i = 0; i < 5; i++) {
21        printf("%d ", arr[i]);
22    }
23    printf("\n");
24    
25    // Resize the array to hold 8 integers
26    int *new_arr = (int*)realloc(arr, 8 * sizeof(int));
27    
28    if (new_arr == NULL) {
29        printf("Memory reallocation failed!\n");
30        free(arr);  // Free the original memory if reallocation fails
31        return 1;
32    }
33    
34    // The original pointer might have changed
35    arr = new_arr;
36    
37    // Initialize the new elements
38    for (int i = 5; i < 8; i++) {
39        arr[i] = (i + 1) * 10;
40    }
41    
42    // Print the resized array
43    printf("Resized array: ");
44    for (int i = 0; i < 8; i++) {
45        printf("%d ", arr[i]);
46    }
47    printf("\n");
48    
49    // Resize to a smaller size
50    arr = (int*)realloc(arr, 3 * sizeof(int));
51    
52    if (arr == NULL) {
53        printf("Memory reallocation failed!\n");
54        return 1;
55    }
56    
57    // Print the downsized array
58    printf("Downsized array: ");
59    for (int i = 0; i < 3; i++) {
60        printf("%d ", arr[i]);
61    }
62    printf("\n");
63    
64    // Free the allocated memory
65    free(arr);
66    
67    return 0;
68}
69

70// Output:
71// Initial array: 10 20 30 40 50
72// Resized array: 10 20 30 40 50 60 70 80
73// Downsized array: 10 20 30

realloc() Syntax

void* realloc(void* ptr, size_t new_size);
  • ptr: Pointer to previously allocated memory block (or NULL)
  • new_size: New size in bytes
  • Return value: Pointer to the reallocated memory, or NULL if allocation fails
  • If ptr is NULL, behaves like malloc(new_size)
  • If new_size is 0 and ptr is not NULL, behaves like free(ptr)
  • Preserves the content of the original memory block up to the minimum of the old and new sizes

Important Note About realloc()

  • Always assign the result of realloc() to a temporary variable first
  • If realloc() fails, it returns NULL but does not free the original memory
  • If you directly assign to the original pointer and realloc() fails, you'll lose the reference to the original memory block, causing a memory leak
// GOOD practice
int *temp = realloc(ptr, new_size);
if (temp != NULL) {
    ptr = temp;
} else {
    // Handle error, original ptr still valid
}

// BAD practice - can cause memory leak if realloc fails
// ptr = realloc(ptr, new_size);

free() - Memory Deallocation

The free() function deallocates memory that was previously allocated by malloc(),calloc(), or realloc().

c
1#include <stdio.h>
2#include <stdlib.h>
3

4int main() {
5    // Allocate memory
6    int *ptr = (int*)malloc(sizeof(int));
7    
8    if (ptr == NULL) {
9        printf("Memory allocation failed!\n");
10        return 1;
11    }
12    
13    *ptr = 42;
14    printf("Value: %d\n", *ptr);
15    
16    // Free the memory
17    free(ptr);
18    
19    // Set the pointer to NULL after freeing
20    ptr = NULL;
21    
22    // Attempting to use the pointer after freeing would be a mistake
23    // printf("Value after free: %d\n", *ptr);  // This would cause undefined behavior
24    
25    // Check if the pointer is NULL before using it
26    if (ptr != NULL) {
27        printf("Value: %d\n", *ptr);
28    } else {
29        printf("Pointer is NULL\n");
30    }
31    
32    return 0;
33}
34

35// Output:
36// Value: 42
37// Pointer is NULL

free() Syntax

void free(void* ptr);
  • ptr: Pointer to memory block to be freed
  • If ptr is NULL, no operation is performed
  • After freeing, the pointer still contains the address, but the memory is no longer valid
  • Best practice: Set pointer to NULL after freeing

Practical Examples

Example 1: Dynamic String Handling

This example demonstrates how to use dynamic memory allocation to handle strings of variable length.

c
1#include <stdio.h>
2#include <stdlib.h>
3#include <string.h>
4

5char* createDynamicString(const char* input) {
6    // Allocate memory for the string (+1 for null terminator)
7    char* str = (char*)malloc(strlen(input) + 1);
8    
9    if (str == NULL) {
10        return NULL;  // Return NULL if allocation fails
11    }
12    
13    // Copy the input string to the allocated memory
14    strcpy(str, input);
15    
16    return str;
17}
18

19int main() {
20    const char* source = "Hello, dynamic memory!";
21    
22    // Create a dynamic string
23    char* dynamic_str = createDynamicString(source);
24    
25    if (dynamic_str == NULL) {
26        printf("Memory allocation failed!\n");
27        return 1;
28    }
29    
30    printf("Original: %s\n", source);
31    printf("Dynamic copy: %s\n", dynamic_str);
32    
33    // Modify the dynamic string
34    dynamic_str[0] = 'h';  // Change 'H' to 'h'
35    printf("Modified: %s\n", dynamic_str);
36    
37    // Free the memory when done
38    free(dynamic_str);
39    dynamic_str = NULL;
40    
41    return 0;
42}
43

44// Output:
45// Original: Hello, dynamic memory!
46// Dynamic copy: Hello, dynamic memory!
47// Modified: hello, dynamic memory!

Example 2: Dynamic Array Resizing

This example shows how to create a dynamic array that grows as needed to accommodate more elements.

c
1#include <stdio.h>
2#include <stdlib.h>
3

4typedef struct {
5    int* array;
6    int size;
7    int capacity;
8} DynamicArray;
9

10// Initialize a dynamic array with initial capacity
11DynamicArray* createDynamicArray(int initialCapacity) {
12    DynamicArray* da = (DynamicArray*)malloc(sizeof(DynamicArray));
13    if (da == NULL) return NULL;
14    
15    da->array = (int*)malloc(initialCapacity * sizeof(int));
16    if (da->array == NULL) {
17        free(da);
18        return NULL;
19    }
20    
21    da->size = 0;
22    da->capacity = initialCapacity;
23    return da;
24}
25

26// Add an element to the dynamic array
27int addElement(DynamicArray* da, int element) {
28    // Check if we need to resize
29    if (da->size >= da->capacity) {
30        // Double the capacity
31        int newCapacity = da->capacity * 2;
32        int* newArray = (int*)realloc(da->array, newCapacity * sizeof(int));
33        
34        if (newArray == NULL) {
35            return 0;  // Failed to resize
36        }
37        
38        da->array = newArray;
39        da->capacity = newCapacity;
40        printf("Array resized to capacity %d\n", newCapacity);
41    }
42    
43    // Add the new element
44    da->array[da->size] = element;
45    da->size++;
46    return 1;  // Success
47}
48

49// Free the dynamic array
50void freeDynamicArray(DynamicArray* da) {
51    if (da != NULL) {
52        free(da->array);
53        free(da);
54    }
55}
56

57int main() {
58    // Create a dynamic array with initial capacity of 2
59    DynamicArray* da = createDynamicArray(2);
60    if (da == NULL) {
61        printf("Failed to create dynamic array\n");
62        return 1;
63    }
64    
65    // Add elements to trigger resizing
66    for (int i = 1; i <= 10; i++) {
67        if (!addElement(da, i * 10)) {
68            printf("Failed to add element %d\n", i);
69            freeDynamicArray(da);
70            return 1;
71        }
72    }
73    
74    // Print all elements
75    printf("Dynamic array elements: ");
76    for (int i = 0; i < da->size; i++) {
77        printf("%d ", da->array[i]);
78    }
79    printf("\n");
80    
81    // Free the dynamic array
82    freeDynamicArray(da);
83    
84    return 0;
85}
86

87// Output:
88// Array resized to capacity 4
89// Array resized to capacity 8
90// Array resized to capacity 16
91// Dynamic array elements: 10 20 30 40 50 60 70 80 90 100

Example 3: Dynamic 2D Array

This example demonstrates how to create a dynamically allocated two-dimensional array.

c
1#include <stdio.h>
2#include <stdlib.h>
3

4// Function to create a dynamic 2D array
5int** create2DArray(int rows, int cols) {
6    // Allocate memory for row pointers
7    int** array = (int**)malloc(rows * sizeof(int*));
8    if (array == NULL) {
9        return NULL;
10    }
11    
12    // Allocate memory for each row
13    for (int i = 0; i < rows; i++) {
14        array[i] = (int*)malloc(cols * sizeof(int));
15        if (array[i] == NULL) {
16            // Free previously allocated memory if allocation fails
17            for (int j = 0; j < i; j++) {
18                free(array[j]);
19            }
20            free(array);
21            return NULL;
22        }
23    }
24    
25    return array;
26}
27

28// Function to free a dynamic 2D array
29void free2DArray(int** array, int rows) {
30    if (array == NULL) return;
31    
32    // Free each row
33    for (int i = 0; i < rows; i++) {
34        free(array[i]);
35    }
36    
37    // Free the row pointers
38    free(array);
39}
40

41int main() {
42    int rows = 3;
43    int cols = 4;
44    
45    // Create a dynamic 2D array
46    int** matrix = create2DArray(rows, cols);
47    if (matrix == NULL) {
48        printf("Memory allocation failed!\n");
49        return 1;
50    }
51    
52    // Initialize the array with values
53    for (int i = 0; i < rows; i++) {
54        for (int j = 0; j < cols; j++) {
55            matrix[i][j] = i * cols + j + 1;
56        }
57    }
58    
59    // Print the array
60    printf("Dynamic 2D Array:\n");
61    for (int i = 0; i < rows; i++) {
62        for (int j = 0; j < cols; j++) {
63            printf("%3d ", matrix[i][j]);
64        }
65        printf("\n");
66    }
67    
68    // Free the array when done
69    free2DArray(matrix, rows);
70    
71    return 0;
72}
73

74// Output:
75// Dynamic 2D Array:
76//   1   2   3   4 
77//   5   6   7   8 
78//   9  10  11  12

Common Memory-Related Errors

Memory Leaks

Occurs when allocated memory is not freed, leading to gradual memory consumption.

Example:

void leak() {
    int *ptr = malloc(sizeof(int));
    *ptr = 42;
    // Missing free(ptr)
    // Memory leak!
}

Use After Free

Accessing memory after it has been freed can cause undefined behavior.

Example:

int *ptr = malloc(sizeof(int));
*ptr = 42;
free(ptr);
printf("%d", *ptr); // BAD: Using freed memory

Double Free

Freeing the same memory block twice can corrupt memory management data structures.

Example:

int *ptr = malloc(sizeof(int));
free(ptr);
free(ptr); // BAD: Double free

Buffer Overflow

Writing beyond allocated memory boundaries can corrupt adjacent memory.

Example:

int *arr = malloc(5 * sizeof(int));
for (int i = 0; i < 10; i++) {
    arr[i] = i; // BAD: Writing beyond bounds

Best Practices for Dynamic Memory Allocation

  • Always check if memory allocation functions return NULL
  • Free all allocated memory when it's no longer needed
  • Set pointers to NULL after freeing them
  • Be careful with realloc() to avoid memory leaks
  • Use tools like Valgrind to detect memory leaks and errors
  • Document memory ownership clearly in your code
  • Consider using wrapper functions for memory management
  • Avoid excessive allocations and deallocations
  • Allocate memory in larger chunks when appropriate
  • Be consistent with your memory management approach

Memory Debugging Tools

Popular Memory Debugging Tools

  • Valgrind: A powerful tool for detecting memory leaks, use-after-free, and other memory errors.
    valgrind --leak-check=full ./your_program
  • AddressSanitizer (ASan): A fast memory error detector built into GCC and Clang.
    gcc -fsanitize=address -g your_program.c -o your_program
  • Electric Fence: A library that helps detect buffer overflows and memory access errors.
  • mtrace: A memory leak detector included in the GNU C Library.

Practice Exercises

🎯 Try these exercises:

  1. Write a function that dynamically allocates memory for a string and reverses it.
  2. Create a program that reads an unknown number of integers from the user and stores them in a dynamically growing array.
  3. Implement a simple memory pool allocator that preallocates a large block of memory and manages smaller allocations from it.
  4. Create a function that merges two dynamically allocated arrays into a new array.
  5. Implement a basic dynamic string class with functions for concatenation, substring extraction, and other string operations.

Summary

In this tutorial, you've learned about dynamic memory allocation in C programming:

  • Dynamic memory allocation allows programs to request memory at runtime
  • The heap is used for dynamic memory, while the stack is used for automatic variables
  • malloc() allocates memory without initialization
  • calloc() allocates memory and initializes it to zero
  • realloc() changes the size of previously allocated memory
  • free() deallocates memory when it's no longer needed
  • Memory leaks, use-after-free, double free, and buffer overflows are common errors to avoid
  • Tools like Valgrind can help detect memory-related errors
  • Following best practices helps ensure efficient and error-free memory management

Dynamic memory allocation is a powerful feature that gives C programmers fine-grained control over memory usage. By mastering these concepts, you'll be able to write more flexible and efficient programs that can adapt to varying runtime conditions.

Previous: Pointers in CNext: Structures in C

Related Tutorials

Pointers in C

Master pointers, a fundamental concept for dynamic memory allocation.

Continue learning

Arrays in C

Learn about working with collections of data in C programming.

Continue learning

Structures in C

Understand how to work with custom data types in C.

Continue learning