2026-04-198 min read

Dynamic memory extensions

Learn Dynamic memory extensions step by step with clear examples and exercises.

Why This Matters

Dynamic memory extensions are essential in C programming for several reasons:

Flexibility: Dynamic memory allows you to create data structures of varying sizes during runtime, adapting to the needs of your program.
Efficiency: By only allocating the exact amount of memory required at a given moment, dynamic memory extensions can help minimize waste and improve performance.
User-friendly input handling: Dynamic memory makes it easier to handle user input with unpredictable lengths, such as reading lines from a file or accepting user input in a console application.
Memory management: Dynamic memory helps manage the memory usage of your program more effectively by allocating and deallocating memory as needed.

Prerequisites

To fully understand dynamic memory extensions in C programming, you should be familiar with:

Basic C syntax and control structures (if-else, loops, etc.)
Data types (int, char, float, etc.)
Variables and constants
Pointers and pointer arithmetic
Functions and function prototypes
Standard library functions such as printf(), scanf(), getchar(), and fopen() for file I/O

Core Concept

Dynamic memory extensions in C are provided by the following functions:

malloc() - Allocates a block of memory with a specified size and returns a pointer to it.
calloc() - Allocates an array of memory, initializes it to zero, and returns a pointer to it.
free() - Deallocates a previously allocated memory block.
realloc() - Resizes a previously allocated memory block and returns a pointer to the new location.
Additional functions for dynamic memory management include sizeof, memcpy, memmove, and memchr.

Allocating Memory with malloc()

The malloc() function is used to allocate a block of memory of a specified size. The function takes one argument, the number of bytes to be allocated. Here's an example:

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

int main(void) {
int *arr;
int n = 10;

// Allocate memory for an array of 10 integers
arr = (int *)malloc(n * sizeof(int));

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

// Use the allocated memory
...

// Free the allocated memory when done
free(arr);

return 0;
}

Allocating and Initializing Memory with calloc()

The calloc() function is used to allocate an array of memory and initialize it to zero. The function takes two arguments: the number of elements in the array and the size of each element. Here's an example:

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

int main(void) {
int *arr;
int n = 10;

// Allocate and initialize memory for an array of 10 integers
arr = (int *)calloc(n, sizeof(int));

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

// Use the allocated and initialized memory
...

// Free the allocated memory when done
free(arr);

return 0;
}

Deallocating Memory with free()

The free() function is used to deallocate a previously allocated memory block. It takes one argument, a pointer to the beginning of the memory block that was allocated using malloc(), calloc(), or realloc(). Here's an example:

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

int main(void) {
int *arr;
int n = 10;

// Allocate memory for an array of 10 integers
arr = (int *)malloc(n * sizeof(int));

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

// Use the allocated memory
...

// Deallocate the allocated memory when done
free(arr);

return 0;
}

Resizing Memory with realloc()

The realloc() function is used to resize a previously allocated memory block and return a pointer to the new location. It takes two arguments: a pointer to the beginning of the memory block that was previously allocated, and the new size of the memory block in bytes. Here's an example:

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

int main(void) {
int *arr;
int n = 10;

// Allocate memory for an array of 10 integers
arr = (int *)malloc(n * sizeof(int));

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

// Use the allocated memory
...

// Allocate memory for an array of 20 integers and resize the existing array
arr = (int *)realloc(arr, n * 2 * sizeof(int));

if (arr == NULL) {
printf("Memory reallocation failed.\n");
return 1;
}

// Use the resized memory
...

// Free the allocated memory when done
free(arr);

return 0;
}

Additional Functions for Dynamic Memory Management

sizeof - Returns the size of a data type or an expression in bytes.
memcpy() - Copies a block of memory from one location to another.
memmove() - Similar to memcpy(), but can copy over overlapping blocks.
memchr() - Searches for the first occurrence of a specific byte within a memory block.

Worked Example

In this example, we will create a program that reads an input line and allocates memory to store the line dynamically. We'll then print the length of the allocated memory and free the memory when done.

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

int main(void) {
char *line;
int n = 0;
char ch;

// Allocate memory for an empty string
line = (char *)malloc(1);

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

while ((ch = getchar()) != '\n') {
// Resize the memory to accommodate the next character
line = (char *)realloc(line, n + 2);

if (line == NULL) {
printf("Memory reallocation failed.\n");
return 1;
}

line[n++] = ch;
line[n] = '\0'; // Ensure null-terminated string
}

printf("The input line has %d characters.\n", n);

// Free the allocated memory when done
free(line);

return 0;
}

Common Mistakes

Forgetting to check for NULL pointers - Always check if malloc(), calloc(), or realloc() returns a non-NULL pointer before using the memory block.
Leaking memory - Make sure to call free() on all dynamically allocated memory blocks when they are no longer needed.
Not accounting for the null terminator - When working with strings, remember to allocate one extra byte for the null terminator and ensure that the string is always null-terminated.
Incorrectly using realloc() - Be careful when resizing memory blocks with realloc(). If the new size is smaller than the original size, the contents of the memory block may be truncated or lost.
Not handling errors properly - Properly handle errors that occur during memory allocation and deallocation to avoid program crashes or unexpected behavior.
Forgetting to initialize dynamically allocated memory - Initializing dynamically allocated memory can help prevent unintended behavior, such as using uninitialized variables.
Ignoring memory leaks - Memory leaks can lead to performance issues and program instability. Make sure to free() all dynamically allocated memory when it is no longer needed.
Not handling memory allocation failures gracefully - Handle memory allocation failures by checking if the returned pointer is NULL, and if so, print an error message and exit the program gracefully. You can also consider using error handling functions from the C standard library like perror() or strerror().
Using free() on a null pointer - Calling free() on a null pointer is undefined behavior and may lead to program crashes or unexpected behavior.
Not considering alignment when using malloc() - The memory allocated by malloc() may not be properly aligned for certain data types, which can lead to issues when accessing the memory. To ensure proper alignment, consider using aligned_alloc() from the C standard library.

Subheadings under Common Mistakes:

Forgetting to initialize dynamically allocated memory
Ignoring memory leaks
Not handling memory allocation failures gracefully
Incorrectly using realloc()
Not accounting for the null terminator
Not considering alignment when using malloc()

Practice Questions

Write a function that takes an integer n as input and returns a dynamically allocated array of n integers filled with the values from 1 to n.
Write a program that reads two lines from the user, concatenates them, and stores the result in a dynamically allocated string.
Write a function that takes a dynamically allocated character array as input and returns the index of the first occurrence of the substring "example" (case-insensitive) within the array. If the substring is not found, return -1.
Write a program that reads an integer n from the user and then dynamically allocates an array of n integers. The user should be able to enter the values for each integer in any order. Once all the integers have been entered, the program should sort them in ascending order using a sorting algorithm of your choice (e.g., bubble sort).
Write a function that takes a dynamically allocated character array as input and returns the number of unique characters in the array.
Write a program that reads an input line from the user, splits it into words using whitespace as a delimiter, and stores each word in a dynamically allocated array of strings. The program should then print the number of words and the length of each word.
Write a function that takes a dynamically allocated character array as input and returns the longest contiguous substring consisting only of vowels (a, e, i, o, u). If no such substring exists, return -1.
Write a program that reads an input file line by line, counts the number of lines containing only alphanumeric characters, and prints the total count.
Write a function that takes a dynamically allocated character array as input and returns the index of the first non-alphanumeric character (assuming alphanumeric characters include uppercase and lowercase letters, numbers, and underscores). If no such character is found, return -1.
Write a program that reads an input file line by line, counts the number of lines containing more than 80 characters, and prints the total count.

FAQ

Why is it important to check for NULL pointers when working with dynamic memory?

Checking for NULL pointers ensures that you handle cases where the memory allocation fails, preventing program crashes and ensuring proper error handling.

What happens if I don't free() dynamically allocated memory?

If you don't free() dynamically allocated memory, it will leak, causing a memory leak in your program and potentially leading to performance issues or program crashes.

Is it better to use malloc() or calloc() for initializing memory with specific values?

calloc() is generally preferred over malloc() when initializing memory with specific values, as it also allocates the memory and initializes it to zero automatically.

What is the difference between realloc() and free()?

realloc() resizes a previously allocated memory block and returns a pointer to the new location, while free() deallocates a previously allocated memory block.

Why do I need to ensure that dynamically allocated strings are null-terminated?

Ensuring that dynamically allocated strings are null-terminated allows you to treat them as C strings and use standard string functions like strlen(), strcmp(), etc., without worrying about out-of-bounds errors.

Why should I avoid using realloc() to shrink a