如何在C语言中动态实现列数可变的二维数组？

方法1：指针数组实现（每行独立分配） #

这种方式逻辑直观，先分配一个指针数组存储每行的地址，再为每行单独分配不同列数的内存块。

代码示例 #

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

int main() {
    int rows = 3;
    // 分配存储行地址的指针数组
    int** arr = (int**)malloc(rows * sizeof(int*));
    if (arr == NULL) {
        perror("malloc failed for rows");
        return 1;
    }

    // 为每行分配不同列数的内存
    arr[0] = (int*)malloc(2 * sizeof(int)); // 第0行2列
    arr[1] = (int*)malloc(4 * sizeof(int)); // 第1行4列
    arr[2] = (int*)malloc(3 * sizeof(int)); // 第2行3列

    // 检查每行内存分配是否成功，失败则释放已分配内存
    for (int i = 0; i < rows; i++) {
        if (arr[i] == NULL) {
            perror("malloc failed for columns");
            for (int j = 0; j < i; j++) {
                free(arr[j]);
            }
            free(arr);
            return 1;
        }
    }

    // 赋值操作
    arr[0][0] = 1; arr[0][1] = 2;
    arr[1][0] = 3; arr[1][1] = 4; arr[1][2] = 5; arr[1][3] = 6;
    arr[2][0] = 7; arr[2][1] = 8; arr[2][2] = 9;

    // 打印数组
    for (int i = 0; i < rows; i++) {
        int cols = (i == 0) ? 2 : (i == 1) ? 4 : 3;
        for (int j = 0; j < cols; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }

    // 释放内存：先释放每行的一维数组，再释放指针数组
    for (int i = 0; i < rows; i++) {
        free(arr[i]);
    }
    free(arr);

    return 0;
}

注意事项 #

• 每行内存独立不连续，适合列数差异较大的场景
• 释放内存必须按顺序：先释放每行的一维数组，再释放指针数组，避免内存泄漏

方法2：一维数组模拟（连续内存） #

如果需要内存连续以提升缓存效率，可以用一块大的一维数组存储所有元素，同时用额外数组记录每行的列数，通过计算偏移量访问元素。

代码示例 #

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

int main() {
    int rows = 3;
    // 记录每行的列数
    int* cols_per_row = (int*)malloc(rows * sizeof(int));
    if (cols_per_row == NULL) {
        perror("malloc failed for cols_per_row");
        return 1;
    }
    cols_per_row[0] = 2;
    cols_per_row[1] = 4;
    cols_per_row[2] = 3;

    // 计算总元素数
    int total_elements = 0;
    for (int i = 0; i < rows; i++) {
        total_elements += cols_per_row[i];
    }

    // 分配连续内存存储所有元素
    int* arr = (int*)malloc(total_elements * sizeof(int));
    if (arr == NULL) {
        perror("malloc failed for arr");
        free(cols_per_row);
        return 1;
    }

    // 赋值操作：通过偏移量定位元素位置
    int offset = 0;
    arr[offset++] = 1; arr[offset++] = 2; // 第0行
    arr[offset++] = 3; arr[offset++] = 4; arr[offset++] = 5; arr[offset++] = 6; // 第1行
    arr[offset++] = 7; arr[offset++] = 8; arr[offset++] = 9; // 第2行

    // 打印数组
    offset = 0;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols_per_row[i]; j++) {
            printf("%d ", arr[offset + j]);
        }
        offset += cols_per_row[i];
        printf("\n");
    }

    // 释放内存
    free(arr);
    free(cols_per_row);

    return 0;
}

注意事项 #

• 内存连续，缓存友好，适合需要整体内存操作的场景
• 需额外存储每行的列数，访问元素时要计算偏移量

内容的提问来源于stack exchange，提问作者Hemanth kumar