PAYATHON 2026

为什么 static 对象不能进行“provisional”声明?

技术老齐

结论

static int a2[]; 不能用来“先声明、后定义”,原因在 C 和 C++ 中并不相同:

  • 在 C 中,这是一条具有内部链接的 tentative definition。由于数组长度未知,数组类型不完整,违反了 C 标准的约束。
  • C++ 没有 C 中的 tentative definition。static int a2[]; 会直接成为定义,而数组定义必须给出大小,或者提供能够推导大小的初始化器。

后面再补上一条完整定义,也无法使前面的声明变得合法。每条声明出现时都必须符合相应的语言规则。

如果能提前确定数组大小,C 可以先写一条使用完整类型的 tentative definition。需要支持 C++ 时,可以在匿名命名空间中使用 extern 声明。

几种写法采用了不同的机制

下面几个例子看起来相似,实际使用的语言机制并不相同。

结构体可以先声明为不完整类型

struct s;

struct s {
    int value;
};

第一行只声明了结构体标签,没有声明或定义对象。C 和 C++ 都允许结构体类型暂时保持不完整。

函数声明不是 tentative definition

static int f2(int);

static int f2(int x)
{
    return x;
}

函数声明只描述函数的类型和链接属性。带有函数体的声明才是定义,所以第一次声明时不需要分配存储空间。

extern 数组声明不是定义

extern int a[];

int a[] = { 1, 2, 3 };

extern int a[]; 只是一条声明,表示数组的定义位于某处,此时不需要知道数组长度。

严格来说,这也不是 tentative definition。C 中典型的 tentative definition 是:

int a[];

这条声明既没有初始化器,也没有 extern。如果直到翻译单元结束仍未出现正式定义,C 会按照标准完成这个 tentative definition。对于届时仍不完整的数组类型,数组会按一个元素处理。

static int a2[]; 为什么不合法

文件作用域中的这条声明:

static int a2[];

会产生两个效果:

  1. static 使 a2 具有内部链接。
  2. 没有初始化器的对象声明会成为 tentative definition。

由于数组长度未知,int[] 是不完整数组类型。C 标准禁止具有内部链接的 tentative definition 使用不完整类型,因此实现必须给出诊断。

即使后面写了完整定义:

static int a2[] = { 1, 2, 3 };

也不能追溯性地修正第一条声明。编译器如果接受这段代码,通常是因为启用了扩展,或者在给出警告后继续编译。这并不代表代码符合严格的 C 标准。诊断的具体形式取决于编译器版本和编译选项。

C 的语法在这里留有一个缺口:无法直接表达“声明一个具有内部链接的对象,但暂时不定义它”。

  • static 可以建立内部链接,但也会使这条对象声明成为 tentative definition。
  • extern 可以避免形成定义,但如果此前没有相关声明,它会建立外部链接。
  • 不能在同一条声明中简单地组合 extern 和 static,同时获得这两种语义。

现有问题材料没有提供委员会制定这项限制时的权威说明,因此无法确定具体动机。从实现角度看,编译器可以把存储分配推迟到翻译单元结束。这个限制更可能源自 C 的声明语法和历史规则,而不是实现上的困难。将它视为语言中的一个小缺陷或不对称之处,是合理的评价。

C 中的可行写法

如果能够提前确定数组大小,可以先声明完整的数组类型:

enum { A2_COUNT = 3 };

static int a2[A2_COUNT];

static int a2[] = {
    10, 20, 30
};

第一条声明仍是 tentative definition,但 int[A2_COUNT] 是完整类型,符合 C 的要求。后面带初始化器的声明是实际定义,两处数组类型必须兼容。

相互引用的数组也可以采用这种写法:

typedef struct Node Node;

struct Node {
    const Node *peer;
};

enum {
    A_COUNT = 1,
    B_COUNT = 1
};

static const Node a[A_COUNT];
static const Node b[B_COUNT];

static const Node a[A_COUNT] = {
    { &b[0] }
};

static const Node b[B_COUNT] = {
    { &a[0] }
};

这种方式要求提前给出数组长度。如果长度只能通过初始化器推导,标准 C 没有语义完全相同的内部链接前置声明写法。一般需要调整定义顺序、显式维护元素数量,或者增加一层指针间接引用。

C++ 使用另一套定义规则

C++ 没有 C 中的 tentative definition。在命名空间作用域中:

static int a2[];

这已经是一条定义,不会等待后续定义。由于它既没有显式大小,也没有可供推导大小的初始化器,程序不符合 C++ 规则。

C++ 编译器并非在更严格地执行同一条 C 规则,而是在执行不同的定义规则。即使提前给出长度:

static int a2[3];
static int a2[] = { 1, 2, 3 };

这段代码在 C++ 中仍然不成立。第一行已经完成定义,第二行会造成重复定义。

C++ 可以使用匿名命名空间

在 C++ 中,可以把数组放入匿名命名空间,再用 extern 进行真正的前置声明:

namespace {

extern int a2[];

int a2[] = {
    10, 20, 30
};

}

extern int a2[]; 是非定义声明,允许数组类型暂时不完整。匿名命名空间则把该名称限制在当前翻译单元内。这样便能分别表达“只声明、不定义”和“仅供当前源文件使用”这两个要求。

相互引用的数据可以写成:

namespace {

struct Node {
    const Node* peer;
};

extern const Node a[];
extern const Node b[];

const Node a[] = {
    { &b[0] }
};

const Node b[] = {
    { &a[0] }
};

}

这种写法既能完成前置声明,也保留了源文件级的封装性,通常是 C++ 中较清楚的解决方案。

注意事项

  • 函数声明、结构体前置声明、extern 对象声明和 C 的 tentative definition 是不同的机制。
  • GCC 或 Clang 接受一段代码,不能单独证明它符合语言标准。对于违反约束的 C 程序,编译器给出诊断后仍可继续生成目标文件。
  • 同时兼容 C 和 C++ 时,不应依赖 C 的 tentative definition 行为。可以显式提供数组大小,或者在 C++ 代码中使用匿名命名空间。
  • 匿名命名空间只适用于 C++,C 没有对应语法。

备注:内容仅供参考。