Dynamic Memory Allocation in C: malloc and free

In C programming, dynamic memory allocation is an important concept. It allows programs to request and release memory as needed during runtime. malloc and free are the two most commonly used functions for dynamic memory management. In this article, we will provide a detailed introduction to the usage of these two functions, along with example code to aid understanding.

Dynamic Memory Allocation

Static memory allocation determines the required memory space at compile time, such as when using arrays. However, in some cases, we do not know how much space will be needed when the program starts running. For example, when the amount of user input is variable, we need to dynamically request and release memory.

1. The malloc Function

malloc (memory allocation) is used to request a block of uninitialized memory of a specified size in bytes, returning a pointer to the first location (of type void *). If sufficient contiguous free space cannot be found, it returns a null pointer.

Syntax

void* malloc(size_t size);

size: The number of bytes to allocate.

Example

Below is a simple example using malloc to create an integer array:

#include <stdio.h>
#include <stdlib.h>
int main() {
    int n;
    printf("Please enter the number of array elements: ");
    scanf("%d", &n);
    // Dynamically request space for n integers
    int* arr = (int*)malloc(n * sizeof(int));
    if(arr == NULL) {
        printf("Memory allocation failed!\n");
        return 1; // Return error status code
    }
    // Input array elements
    for(int i = 0; i < n; i++) {
        printf("Input the %dth element: ", i + 1);
        scanf("%d", &arr[i]);
    }
    // Output array elements
    printf("The array you entered is:\n");
    for(int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    // Free the allocated space after use
    free(arr);
    return 0;
}

2. The free Function

When we successfully allocate a block of dynamic memory using malloc, we must remember to call free when we no longer need it to avoid memory leaks.

Syntax

void free(void* ptr);

ptr: A pointer to the memory location previously allocated by malloc, calloc, or realloc.

Example demonstrating how to free the space allocated to an integer array by malloc:

Based on the previous code, after using the array, we must call:

free(arr);

to ensure that no data is lost and to prevent double freeing.

Precautions

Check for null pointers: Always check if the return value from malloc() is null to ensure the system has enough available memory.
Matching: Each successful call to malloc must correspond to a call to free; otherwise, over time, memory will be depleted, leading to issues.
Do not free the same address value multiple times: Never call free on an already freed address, as this may cause undefined behavior.
Correct type casting: Although in C, type casting is not mandatory, it is recommended for readability to cast to the appropriate type.
Proper resource cleanup: It is advisable to minimize risks by properly managing resources and ensuring that memory is released appropriately.

Conclusion

This article briefly introduces the application aspects of dynamic memory allocation in C, providing a step-by-step analysis of the malloc and free functions, which is beneficial for deepening understanding and enhancing design thinking in future projects.

Dynamic Memory Allocation in C: malloc and free