Arrays in C

[MarkosComK]

Body

Question:

How do you dynamically allocate a 2D array in C, and what are the common pitfalls when working with dynamically allocated multi-dimensional arrays?

Specifically, consider the following requirements:

• You need to allocate a 2D array of int with dimensions n x m, where both n and m are provided at runtime.
• Implement a function that allocates this 2D array and returns a pointer to it.
• Ensure that you free the memory correctly once you're done with the array.

Provide a code example that demonstrates the correct memory allocation, usage, and deallocation, and explain any potential issues or mistakes programmers commonly make when working with such arrays.

Guidelines

• I have read and understood this category's guidelines before making this post.

[SirAlabar]

To dynamically allocate a 2D array in C with dimensions n x m, where both n and m are provided at runtime, you can use the following steps:

Allocate memory for an array of n pointers.
For each pointer, allocate memory for an array of m integers.

Common Pitfalls:

Incorrect memory deallocation: Forgetting to free each row before freeing the array of pointers.
Memory leaks: Not freeing the memory properly can lead to memory leaks.
Incorrect pointer arithmetic: Mixing up the concept of a 2D array and a 1D array can result in access violations.

Below is a code example demonstrating the correct way to dynamically allocate, use, and free a 2D array.
Code Example

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

// Function to allocate memory for a 2D array
int **allocate_2d_array(int n, int m) {
    int **array = malloc(n * sizeof(int *));  // Allocate memory for row pointers
    if (array == NULL) {
        return NULL;  // Memory allocation failed
    }
    
    for (int i = 0; i < n; i++) {
        array[i] = malloc(m * sizeof(int));  // Allocate memory for each row
        if (array[i] == NULL) {
            // If allocation fails, free already allocated memory
            for (int j = 0; j < i; j++) {
                free(array[j]);
            }
            free(array);
            return NULL;
        }
    }
    
    return array;
}

// Function to free the memory allocated for the 2D array
void free_2d_array(int **array, int n) {
    for (int i = 0; i < n; i++) {
        free(array[i]);  // Free each row
    }
    free(array);  // Free the array of pointers
}

int main() {
    int n = 3, m = 4;  // Example dimensions

    // Allocate memory for the 2D array
    int **array = allocate_2d_array(n, m);
    
    if (array == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // Use the 2D array (e.g., filling it with values)
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            array[i][j] = i * m + j;
        }
    }

    // Print the 2D array
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            printf("%d ", array[i][j]);
        }
        printf("\n");
    }

    // Free the allocated memory
    free_2d_array(array, n);

    return 0;
}

Explanation:

Allocation:
    We first allocate memory for n pointers (rows).
    Then, we allocate memory for each row, each containing m integers.
Memory Deallocation:
    We free each row individually.
    Finally, we free the array of pointers itself.

Common Mistakes:

Memory Leaks: Failing to free both the individual rows and the array of pointers.
Null Checks: Not checking if malloc returns NULL when memory allocation fails.
Memory Overwrites: Not keeping track of allocated rows properly can lead to access violations.

This approach ensures you can dynamically allocate, use, and correctly deallocate a 2D array in C.