如何在C语言中创建用户自定义大小的结构体二维数组

你可以通过两种方式实现需求，下面分别给出具体方案：

方案一：使用可变长度数组（VLA）（C99及以上标准支持） #

C99允许在函数内部定义包含可变长度数组的结构体，数组大小由运行时输入的SIZE决定。这种方式实现简单，内存自动管理，但受栈空间限制，适合SIZE较小的场景。

示例代码：

#include <stdio.h>

int main() {
    int SIZE;
    printf("输入SIZE的值：");
    scanf("%d", &SIZE);

    // 在函数内部定义带可变长度数组的结构体
    struct args {
        int number;
        int array[SIZE][SIZE];
    };

    // 创建单个结构体实例
    struct args my_args;
    // 若需要结构体数组，可写成：struct args args_list[5]; // 5个结构体实例

    // 测试赋值与输出
    my_args.number = 10;
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            my_args.array[i][j] = i * SIZE + j;
        }
    }

    printf("number: %d\n", my_args.number);
    printf("array:\n");
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            printf("%d ", my_args.array[i][j]);
        }
        printf("\n");
    }

    return 0;
}

注意事项：

• 带VLA的结构体只能在函数内部定义，不能作为全局结构体
• 栈空间大小有限，若SIZE过大可能触发栈溢出错误
• 部分老版本编译器可能不支持C99标准，需确保编译器开启C99及以上支持

方案二：动态内存分配（通用兼容，适合大SIZE场景） #

通过指针+malloc动态分配内存，这种方式不受栈空间限制，兼容性更好（支持C89及以上），但需要手动管理内存避免泄漏。

示例代码：

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

// 全局定义结构体，用指针存储二维数组
struct args {
    int number;
    int **array;
    int size; // 记录数组尺寸，方便后续操作
};

int main() {
    int SIZE;
    printf("输入SIZE的值：");
    scanf("%d", &SIZE);

    // 分配单个结构体实例的内存
    struct args *my_args = malloc(sizeof(struct args));
    if (my_args == NULL) {
        perror("结构体内存分配失败");
        return 1;
    }
    my_args->size = SIZE;
    my_args->number = 20;

    // 分配二维数组的外层指针内存
    my_args->array = malloc(SIZE * sizeof(int*));
    if (my_args->array == NULL) {
        perror("数组外层指针分配失败");
        free(my_args);
        return 1;
    }

    // 分配二维数组的内层每个行的内存
    for (int i = 0; i < SIZE; i++) {
        my_args->array[i] = malloc(SIZE * sizeof(int));
        if (my_args->array[i] == NULL) {
            perror("数组行内存分配失败");
            // 释放已分配的内存，避免泄漏
            for (int j = 0; j < i; j++) {
                free(my_args->array[j]);
            }
            free(my_args->array);
            free(my_args);
            return 1;
        }
    }

    // 测试赋值与输出
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            my_args->array[i][j] = i * SIZE + j;
        }
    }

    printf("number: %d\n", my_args->number);
    printf("array:\n");
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            printf("%d ", my_args->array[i][j]);
        }
        printf("\n");
    }

    // 释放内存，顺序与分配相反
    for (int i = 0; i < SIZE; i++) {
        free(my_args->array[i]);
    }
    free(my_args->array);
    free(my_args);

    return 0;
}

若需要创建结构体的二维数组 #

如果要生成M×N的struct args二维数组，可参考以下代码片段：

int M = 3, N = 2; // 结构体数组的行数和列数
struct args **args_arr = malloc(M * sizeof(struct args*));
if (args_arr == NULL) {
    perror("结构体数组外层分配失败");
    return 1;
}

for (int i = 0; i < M; i++) {
    args_arr[i] = malloc(N * sizeof(struct args));
    if (args_arr[i] == NULL) {
        perror("结构体数组行分配失败");
        // 释放已分配内存
        for (int j = 0; j < i; j++) {
            free(args_arr[j]);
        }
        free(args_arr);
        return 1;
    }

    // 为每个结构体实例分配内部二维数组内存
    for (int j = 0; j < N; j++) {
        args_arr[i][j].size = SIZE;
        args_arr[i][j].number = i * N + j;
        // 分配array内存（同方案二中的步骤）
        args_arr[i][j].array = malloc(SIZE * sizeof(int*));
        // ...后续的内存分配与错误处理逻辑
    }
}

注意事项：

• 动态分配的内存必须手动释放，释放顺序要与分配顺序相反
• 每次malloc后都要检查返回值是否为NULL，避免空指针错误

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