Dynamic memory allocation in C is a technique that allows programs to request memory during runtime, rather than at compile time. This flexibility is crucial for managing memory efficiently, especially when the size of data structures (like arrays, linked lists, etc.) is not known beforehand. Here’s an in-depth look at dynamic memory allocation in C.

1. Key Functions for Dynamic Memory Allocation

In C, dynamic memory allocation is primarily managed using four standard library functions, which are declared in the <stdlib.h> header:

• malloc (Memory Allocation)
• calloc (Contiguous Allocation)
• realloc (Reallocation)
• free (Deallocation)

2. malloc Function

The malloc function allocates a specified number of bytes of memory and returns a pointer to the first byte of the allocated memory. The memory is uninitialized, meaning it may contain garbage values.

Syntax

void* malloc(size_t size);

Example

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

int main() {
    int *arr;
    int n;

    printf("Enter number of elements: ");
    scanf("%d", &n);

    // Dynamically allocate memory for n integers
    arr = (int *)malloc(n * sizeof(int));

    // Check if memory allocation was successful
    if (arr == NULL) {
        printf("Memory allocation failed!\n");
        return 1;  // Exit if allocation failed
    }

    // Initialize and print the array
    for (int i = 0; i < n; i++) {
        arr[i] = i * 10;  // Assign values
        printf("%d ", arr[i]);
    }

    // Free the allocated memory
    free(arr);

    return 0;
}

Output Example (assuming n = 5):

Enter number of elements: 5
0 10 20 30 40 

3. calloc Function

The calloc function allocates memory for an array of elements and initializes all bytes to zero. It takes two arguments: the number of elements and the size of each element.

Syntax

void* calloc(size_t num, size_t size);

Example

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

int main() {
    int *arr;
    int n;

    printf("Enter number of elements: ");
    scanf("%d", &n);

    // Dynamically allocate memory for n integers and initialize to zero
    arr = (int *)calloc(n, sizeof(int));

    // Check if memory allocation was successful
    if (arr == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // Print the initialized array
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);  // Outputs 0 for each element
    }

    // Free the allocated memory
    free(arr);

    return 0;
}

Output Example (assuming n = 5):

Enter number of elements: 5
0 0 0 0 0 

4. realloc Function

The realloc function is used to resize a previously allocated memory block. It can also be used to change the size of the memory block pointed to by a pointer.

Syntax

void* realloc(void* ptr, size_t size);

Example

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

int main() {
    int *arr;
    int n;

    printf("Enter initial number of elements: ");
    scanf("%d", &n);

    // Allocate initial memory
    arr = (int *)malloc(n * sizeof(int));

    // Check if memory allocation was successful
    if (arr == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // Initialize array
    for (int i = 0; i < n; i++) {
        arr[i] = i + 1;  // Assign values
    }

    // Resize the array
    printf("Enter new number of elements: ");
    scanf("%d", &n);
    arr = (int *)realloc(arr, n * sizeof(int));

    // Check if reallocation was successful
    if (arr == NULL) {
        printf("Reallocation failed!\n");
        return 1;
    }

    // Initialize new elements
    for (int i = 0; i < n; i++) {
        arr[i] += 10;  // Modify the array
    }

    // Print the modified array
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    // Free the allocated memory
    free(arr);

    return 0;
}

5. free Function

The free function is used to deallocate previously allocated memory. It takes a pointer as an argument, and after calling free, that pointer becomes invalid.

Example

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

int main() {
    int *arr;
    int n;

    // Dynamic allocation (example as shown previously)
    // ...

    // Free allocated memory
    free(arr);

    return 0;
}

6. Important Considerations

• Memory Leak: If you forget to free dynamically allocated memory, it can lead to memory leaks, where the memory is no longer accessible but has not been released back to the system.
• Dangling Pointer: After calling free, the pointer still points to the memory location, but that memory is no longer valid. Accessing it can lead to undefined behavior.
• Check for NULL: Always check if the memory allocation functions (malloc, calloc, realloc) return NULL, which indicates that the allocation failed.

Summary

Dynamic memory allocation in C allows for efficient and flexible memory management during runtime. By using functions like malloc, calloc, realloc, and free, you can allocate, initialize, resize, and release memory as needed, enabling the creation of complex data structures like linked lists, trees, and dynamic arrays. Understanding how to manage dynamic memory is crucial for writing efficient and effective C programs.