C语言结构体数组动态新增条目：变量作数组大小编译报错问题

你的这个思路是不可行的，我来给你拆解原因和解决办法：

首先，C语言里声明静态数组的时候，要求数组的大小必须是编译期就能确定的常量。你用int i这种运行时变量来定义数组大小，编译器没办法在编译阶段知道i的值，所以肯定会报错。而用#define定义的常量是预处理阶段就固定的，确实能过编译，但它是个死值，程序运行时没法修改，自然实现不了你“新增条目时递增i”的需求。

接下来给你几个可行的解决方案，按实用性排序：

1. 动态内存分配（最推荐） #

用malloc和realloc函数在堆上动态分配内存，这样就能随时调整数组的大小，完美满足你新增条目的需求。举个完整的例子：

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

struct order { 
    char orderName[15]; 
    int orderQuantity; 
    int orderUnderTen; 
    int orderUnderSixteen; 
    int orderStudent; 
    int orderOverSixty; 
    int orderNA; 
    double orderTotal; 
};

int main() {
    // 先给数组分配1个元素的初始空间
    struct order *orders = malloc(sizeof(struct order));
    if (orders == NULL) { // 一定要检查内存分配是否成功，避免崩溃
        perror("Failed to allocate initial memory");
        return 1;
    }
    int current_count = 1; // 当前数组里的条目数

    // 初始化第一个订单
    strcpy(orders[0].orderName, "John");
    orders[0].orderQuantity = 5;
    orders[0].orderUnderTen = 0;
    orders[0].orderUnderSixteen = 0;
    orders[0].orderStudent = 0;
    orders[0].orderOverSixty = 0;
    orders[0].orderNA = 5;
    orders[0].orderTotal = 25.00;

    // 新增一个订单的操作
    current_count++;
    // 重新分配内存，扩大到current_count个元素
    struct order *temp = realloc(orders, current_count * sizeof(struct order));
    if (temp == NULL) {
        perror("Failed to reallocate memory");
        free(orders); // 释放原来的内存，防止内存泄漏
        return 1;
    }
    orders = temp; // 更新指针到新的内存块

    // 初始化新增的订单
    strcpy(orders[1].orderName, "Alice");
    orders[1].orderQuantity = 3;
    orders[1].orderNA = 3;
    orders[1].orderTotal = 15.00;
    // 其他字段按需赋值

    // 用完内存后记得释放！
    free(orders);
    return 0;
}

这个方法的好处是既能像数组一样通过下标快速访问元素，又能随时扩容，完全符合你的需求。

2. 变长数组（VLA，仅适合简单场景） #

如果你的编译器支持C99或更高版本，可以使用变长数组——也就是用变量定义数组大小。但注意：

• VLA是在栈上分配的，栈空间很小，不能用来存太多条目；
• VLA声明后大小就固定了，没法动态扩容；
• 不能在声明VLA时直接初始化（像你原来那样给数组赋值是不行的）。

示例代码：

#include <stdio.h>
#include <string.h>

struct order { 
    char orderName[15]; 
    int orderQuantity; 
    // 其他字段...
    double orderTotal; 
};

int main() {
    int i = 2;
    struct order s[i]; // 这在C99及以后是合法的

    // 逐个初始化元素
    strcpy(s[0].orderName, "John");
    s[0].orderQuantity = 5;
    s[0].orderTotal = 25.00;

    strcpy(s[1].orderName, "Alice");
    s[1].orderQuantity = 3;
    s[1].orderTotal = 15.00;

    return 0;
}

但这个方法不适合你需要“递增新增条目”的场景，因为数组大小一旦确定就改不了，所以只适合提前知道大概条目数的情况。

3. 链表（适合频繁增删的场景） #

如果你的场景是频繁新增/删除条目，用链表会更灵活。链表不需要提前分配固定大小的内存，每个条目作为一个节点，新增时就创建新节点并链接到链表上。缺点是访问元素需要遍历链表，不如数组方便。

示例代码：

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

struct order { 
    char orderName[15]; 
    int orderQuantity; 
    // 其他字段...
    double orderTotal; 
    struct order *next; // 指向链表下一个节点的指针
};

int main() {
    // 创建第一个节点
    struct order *head = malloc(sizeof(struct order));
    if (head == NULL) {
        perror("Failed to create first node");
        return 1;
    }
    strcpy(head->orderName, "John");
    head->orderQuantity = 5;
    head->orderTotal = 25.00;
    head->next = NULL; // 链表末尾的next指针设为NULL

    // 新增一个节点
    struct order *new_node = malloc(sizeof(struct order));
    if (new_node == NULL) {
        perror("Failed to create new node");
        free(head); // 释放已创建的节点，避免内存泄漏
        return 1;
    }
    strcpy(new_node->orderName, "Alice");
    new_node->orderQuantity = 3;
    new_node->orderTotal = 15.00;
    new_node->next = head; // 把新节点插在头部
    head = new_node; // 更新链表头指针

    // 遍历链表打印所有订单
    struct order *current = head;
    while (current != NULL) {
        printf("Order: %s, Total: %.2f\n", current->orderName, current->orderTotal);
        struct order *temp = current;
        current = current->next;
        free(temp); // 遍历后释放节点
    }

    return 0;
}

总结一下：如果只是需要动态新增条目，优先用动态内存分配的方案；如果是频繁增删，再考虑链表；变长数组只适合简单的固定大小场景。

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