关于 C 中的数组初始化的困惑

Question

在C语言中，如果这样初始化一个数组：

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

那么数组中所有未显式初始化的元素都将被隐式初始化为零。

但是，如果我像这样初始化一个数组：

int a[5]={a[2]=1};

printf("%d %d %d %d %d\n", a[0], a[1],a[2], a[3], a[4]);

输出：

1 0 1 0 0

我不明白，为什么a[0] 打印1 而不是0？是未定义的行为吗？

注意：这个问题是在一次采访中提出的。

Answer 1

TL;DR：我认为int a[5]={a[2]=1}; 的行为没有明确定义，至少在 C99 中是这样。

有趣的是，对我来说唯一有意义的是您要询问的部分：a[0] 设置为 1，因为赋值运算符返回分配的值。其他都不清楚。

如果代码是int a[5] = { [2] = 1 }，一切都会很简单：这是一个指定的初始化设置a[2] 到1 和其他一切到0。但是对于{ a[2] = 1 }，我们有一个包含赋值表达式的非指定初始化程序，我们掉进了一个兔子洞。

---

这是我目前发现的：

• a 必须是局部变量。

  6.7.8 初始化

  4. 具有静态存储持续时间的对象的初始化程序中的所有表达式都应为常量表达式或字符串文字。

  a[2] = 1 不是常量表达式，所以a 必须有自动存储。

• a 在它自己的初始化范围内。

  6.2.1 标识符的范围

  1. 结构、联合和枚举标记的范围从出现在 声明标签的类型说明符中的标签。每个枚举常量的范围 在其定义的枚举数出现在枚举数列表中之后开始。 任何 其他标识符的范围在其声明符完成后开始。

  声明符是a[5]，因此变量在它们自己的初始化范围内。

• a 在它自己的初始化中是存活的。

  6.2.4 对象的存储时长

  4. 一个对象，其标识符被声明为没有链接且没有存储类 说明符 static 具有自动存储期限。

  5. 对于这样一个没有变长数组类型的对象，它的生命周期会延长 从进入与其关联的块直到该块的执行结束 反正。 （进入封闭块或调用函数会暂停，但不会结束， 执行当前块。）如果块是递归进入的，则该块的新实例 每次都会创建对象。对象的初始值是不确定的。如果 为对象指定初始化，每次声明时执行 在执行块时达到；否则，每个值都变得不确定 到达声明的时间。

• a[2]=1之后有一个序列点。

  6.8 语句和块

  4. 完整表达式是不属于另一个表达式或声明符的表达式。 下面的每一个都是一个完整的表达式：一个初始化器；表达式中的表达式 陈述;选择语句的控制表达式（if 或 switch）；这 控制while 或do 语句的表达式；的每个（可选）表达式 for 声明； return 语句中的（可选）表达式。 完整的结束 表达式是一个序列点。

  请注意，例如在int foo[] = { 1, 2, 3 } 中，{ 1, 2, 3 } 部分是一个用大括号括起来的初始化器列表，每个初始化器后面都有一个序列点。

• 按照初始化列表顺序执行初始化。

  6.7.8 初始化

  17. 每个用大括号括起来的初始化器列表都有一个关联的当前对象。没有时 指定存在，当前对象的子对象按顺序初始化 到当前对象的类型：下标递增顺序的数组元素，声明顺序的结构成员，以及联合的第一个命名成员。 [...]

   

  19. 初始化应按初始化程序列表顺序进行，每个初始化程序提供一个 覆盖同一子对象的任何先前列出的初始化程序的特定子对象；全部 未显式初始化的子对象应隐式初始化，与 具有静态存储持续时间的对象。

• 但是，初始化表达式不一定按顺序计算。

  6.7.8 初始化

  23. 在初始化列表表达式中出现任何副作用的顺序是 未指定。

---

然而，这仍有一些问题没有得到解答：

• 序列点是否相关？基本规则是：

  6.5 表达式

  1. 在上一个序列点和下一个序列点之间，对象应具有其存储值 最多修改一次通过表达式的评估。此外，先验值 应只读以确定要存储的值。

  a[2] = 1 是一个表达式，但初始化不是。

  这与附件 J 略有矛盾：

  J.2 未定义行为

  • 在两个序列点之间，一个对象被多次修改，或者被修改 并且读取先验值而不是确定要存储的值 (6.5)。

  附件 J 指出任何修改都算数，而不仅仅是表达式的修改。但鉴于附件是非规范性的，我们可能可以忽略它。

• 子对象初始化相对于初始化表达式是如何排序的？是否首先评估所有初始化程序（按某种顺序），然​​后用结果初始化子对象（按初始化程序列表顺序）？还是可以交错？

---

我认为int a[5] = { a[2] = 1 }执行如下：

1. a 的存储空间在进入其包含块时分配。此时内容不确定。
2. （唯一的）初始化程序被执行（a[2] = 1），然后是一个序列点。这会将1 存储在a[2] 中并返回1。
3. 那个1用来初始化a[0]（第一个初始化器初始化第一个子对象）。

但是这里事情变得模糊了，因为剩余的元素（a[1]、a[2]、a[3]、a[4]）应该被初始化为0，但不清楚什么时候：它发生在@之前987654359@被评估了吗？如果是这样，a[2] = 1 将“获胜”并覆盖a[2]，但该赋值是否会因为在零初始化和赋值表达式之间没有序列点而具有未定义的行为？序列点是否相关（见上文）？还是在评估所有初始化程序之后发生零初始化？如果是这样，a[2] 最终应该是 0。

由于 C 标准没有明确定义此处发生的情况，我认为该行为是未定义的（通过遗漏）。

Answer 2

我不明白，为什么a[0] 打印1 而不是0？

大概a[2]=1先初始化a[2]，然后用表达式的结果来初始化a[0]。

来自 N2176（C17 草案）：

6.7.9 初始化

23. 初始化列表表达式的求值顺序不确定 彼此之间，因此未指定任何副作用发生的顺序。 ¹⁵⁴⁾

所以看起来输出1 0 0 0 0 也是可能的。

结论：不要编写动态修改已初始化变量的初始化程序。

Answer 3

我认为 C11 标准涵盖了这种行为并表示结果 未指定，我认为 C18 没有在 这个区域。

标准语言不容易解析。 该标准的相关部分是 §6.7.9 Initialization。 语法记录为：

initializer:
assignment-expression
{ initializer-list }
{ initializer-list , }
initializer-list:
designationopt initializer
initializer-list , designationopt initializer
designation:
designator-list =
designator-list:
designator
designator-list designator
designator:
[ constant-expression ]
. identifier

请注意，其中一个术语是 assignment-expression，由于a[2] = 1 无疑是一个赋值表达式，所以它可以在里面 具有非静态持续时间的数组的初始化器：

§4 对象的初始化程序中的所有表达式 静态或线程存储持续时间应为常量表达式或 字符串字面量。

其中一个关键段落是：

§19 初始化应按初始化列表顺序进行，每个 为覆盖任何特定子对象提供的初始化程序 先前列出的相同子对象的初始化程序；¹⁵¹⁾ 所有未显式初始化的子对象都应 隐式初始化与具有静态存储的对象相同 持续时间。

¹⁵¹⁾ 被覆盖的子对象的任何初始化器 因此不用于初始化该子对象可能不会在 全部。

另一个关键段落是：

§23 初始化列表表达式的求值是 相对于彼此不确定地排序，因此 未指定任何副作用发生的顺序。¹⁵²⁾

¹⁵²⁾ 特别是，评估顺序不必是 与子对象初始化的顺序相同。

我相当确定第 23 段表明 问题：

int a[5] = { a[2] = 1 };

导致未指定的行为。 分配给a[2] 是一个副作用，并且 表达式之间的顺序是不确定的。 因此，我认为没有一种方法可以诉诸该标准并且 声称特定的编译器正在正确或错误地处理此问题。

Answer 4

我的理解是 a[2]=1 返回值 1 所以代码变成了

int a[5]={a[2]=1} --> int a[5]={1}

int a[5]={1} 为 a[0]=1 赋值

因此它为 a[0]

打印 1

例如

char str[10]={‘H’,‘a’,‘i’};


char str[0] = ‘H’;
char str[1] = ‘a’;
char str[2] = ‘i;

Answer 5

我试着给出一个简短的答案：int a[5] = { a[2] = 1 };

1. 首先设置a[2] = 1。这意味着数组说：0 0 1 0 0
2. 但是请注意，鉴于您是在用于按顺序初始化数组的{ } 括号中进行的，它采用第一个值（即1）并将其设置为a[0]。就好像int a[5] = { a[2] }; 会保留，而我们已经得到a[2] = 1。结果数组现在是：1 0 1 0 0

另一个例子：int a[6] = { a[3] = 1, a[4] = 2, a[5] = 3 }; - 尽管顺序有些随意，假设它是从左到右，它会按以下 6 个步骤进行：

0 0 0 1 0 0
1 0 0 1 0 0
1 0 0 1 2 0
1 2 0 1 2 0
1 2 0 1 2 3
1 2 3 1 2 3

Answer 6

赋值a[2]= 1 是一个具有值1 的表达式，而您实际上是写了int a[5]= { 1 };（副作用是a[2] 也被赋值为1）。

Answer 7

我相信，int a[5]={ a[2]=1 }; 是程序员开枪打自己脚的好例子。

我可能会认为您的意思是 int a[5]={ [2]=1 };，它是 C99 指定的初始化程序，将元素 2 设置为 1，其余设置为零。

在极少数情况下，你真的是指int a[5]={ 1 }; a[2]=1;，那么这将是一种有趣的写作方式。无论如何，这就是您的代码归结为的内容，尽管这里有些人指出，在实际执行对a[2] 的写入时，它的定义并不明确。这里的陷阱是a[2]=1 不是一个指定的初始化器，而是一个简单的赋值，它本身的值为 1。