为何全局静态结构体数组初始化合法，函数内静态版本却报错？

问题现象 #

当在全局作用域声明静态结构体数组时，使用复合字面量初始化可以正常编译运行：

#include <stdio.h>

enum
{
    Mammals,
    Amphibians,
    Avians,
    Fish,
    Human,  Elephant,   Horse,
    Frog,   Salamander,
    Eagle, Sparrow, Duck,
    Salmon, Carp, Tuna
};

typedef struct
{
    int category;
    int* examples;
    int num_examples;
} classification_t;

// 全局静态数组，初始化正常
static classification_t classifications[] = {
    { Mammals,    (int[]){Human, Elephant, Horse}, 3 },
    { Amphibians, (int[]){Frog, Salamander},       2 },
    { Avians,     (int[]){Eagle, Sparrow, Duck},   3 },
    { Fish,       (int[]){Salmon, Carp, Tuna},     3 }
};

int main(void)
{
    for(int i=0; i<4; ++i)
    {
        printf("Category %d has %d examples\n", classifications[i].category, classifications[i].num_examples);
    }
    
    return 0;
}

输出：

Category 0 has 3 examples
Category 1 has 2 examples
Category 2 has 3 examples
Category 3 has 3 examples

但将该静态数组移至函数（如main）内部时，编译器会报错error: initializer element is not constant：

#include <stdio.h>

enum
{
    Mammals,
    Amphibians,
    Avians,
    Fish,
    Human,  Elephant,   Horse,
    Frog,   Salamander,
    Eagle, Sparrow, Duck,
    Salmon, Carp, Tuna
};

typedef struct
{
    int category;
    int* examples;
    int num_examples;
} classification_t;

int main(void)
{
    // 函数内静态数组，初始化报错
    static classification_t classifications[] = {
        { Mammals,    (int[]){Human, Elephant, Horse}, 3 },
        { Amphibians, (int[]){Frog, Salamander},       2 },
        { Avians,     (int[]){Eagle, Sparrow, Duck},   3 },
        { Fish,       (int[]){Salmon, Carp, Tuna},     3 }
    };

    for(int i=0; i<4; ++i)
    {
        printf("Category %d has %d examples\n", classifications[i].category, classifications[i].num_examples);
    }
    
    return 0;
}

简化后的问题更直观：

static int* foo = (int[]) { 3, 4, 5 }; // 全局静态，合法

int main()
{
  static int* foo = (int[]) { 3, 4, 5 }; // 函数内静态，不合法
  static int* foo = (static int[]) { 3, 4, 5 }; // 语法错误，static不能加在这里
}

报错原因 #

这是C语言标准对变量初始化的规则限制：

• 全局作用域的复合字面量（如(int[]){...}）属于静态存储期，它的地址是编译阶段可确定的常量表达式，因此可以用来初始化全局静态变量。
• 函数作用域内的复合字面量默认属于自动存储期（即存储在栈上），它的地址是运行时才确定的，不属于常量表达式；而函数内的静态变量要求初始化值必须是常量表达式，因此编译器报错。
• C标准不允许在复合字面量前添加static关键字（如(static int[]){...}），这属于语法错误。

解决方法 #

方案1：将内嵌示例数组单独声明为静态变量 #

把每个分类对应的示例数组先在函数内声明为静态数组，再用它们的地址初始化结构体数组，这是兼容性最好的解法：

#include <stdio.h>

enum
{
    Mammals,
    Amphibians,
    Avians,
    Fish,
    Human,  Elephant,   Horse,
    Frog,   Salamander,
    Eagle, Sparrow, Duck,
    Salmon, Carp, Tuna
};

typedef struct
{
    int category;
    int* examples;
    int num_examples;
} classification_t;

int main(void)
{
    // 先单独声明静态示例数组
    static int mammals_examples[] = {Human, Elephant, Horse};
    static int amphibians_examples[] = {Frog, Salamander};
    static int avians_examples[] = {Eagle, Sparrow, Duck};
    static int fish_examples[] = {Salmon, Carp, Tuna};

    // 用静态数组的地址初始化结构体数组
    static classification_t classifications[] = {
        { Mammals,    mammals_examples, 3 },
        { Amphibians, amphibians_examples, 2 },
        { Avians,     avians_examples, 3 },
        { Fish,       fish_examples, 3 }
    };

    for(int i=0; i<4; ++i)
    {
        printf("Category %d has %d examples\n", classifications[i].category, classifications[i].num_examples);
    }
    
    return 0;
}

对应简化问题的解法：

int main()
{
  static int arr[] = {3,4,5};
  static int* foo = arr; // 合法，静态数组的地址是常量表达式
}

方案2：使用const限定的复合字面量（C99+，依赖编译器优化） #

如果将结构体的examples成员改为const int*，可以用const复合字面量初始化。部分编译器会将函数内的const复合字面量优化为静态存储期，使其地址成为常量表达式：

typedef struct
{
    int category;
    const int* examples; // 修改为const指针
    int num_examples;
} classification_t;

int main(void)
{
    static classification_t classifications[] = {
        { Mammals,    (const int[]){Human, Elephant, Horse}, 3 },
        { Amphibians, (const int[]){Frog, Salamander},       2 },
        { Avians,     (const int[]){Eagle, Sparrow, Duck},   3 },
        { Fish,       (const int[]){Salmon, Carp, Tuna},     3 }
    };
    // ... 后续代码不变
}

注意：这种写法依赖编译器实现，并非所有编译器都支持，相比方案1兼容性较差。

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