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

在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？它是不确定的行为吗？

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

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标识符范围

  7. 结构，联合和枚举标签的作用域始于在声明标签的类型说明符中出现标签之后。每个枚举常量的作用域都在其定义的枚举器出现在枚举器列表之后立即开始。任何其他标识符的作用域都在其声明符完成之后立即开始。

  声明符为a[5]，因此变量在其自身的初始化范围内。

• a 在自己的初始化中还活着。

  6.2.4对象的存储期限

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

  5. 对于不具有可变长度数组类型的对象，其生存期从进入与之关联的块开始，一直到该块的执行以任何方式结束。（进入封闭的块或调用函数会挂起，但不会结束当前块的执行。）如果递归地输入该块，则每次都会创建该对象的新实例。对象的初始值不确定。如果为该对象指定了初始化，则每次在执行块时到达声明时都将执行该初始化。否则，每次到达声明时，该值将变得不确定。

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

  6.8语句和块

  4. 甲充分表达是不是另一个表达式或一声明符的一部分的表达。下列各是一个完整的表达：一个初始化 ; 表达式语句中的表达式；选择语句（if或switch）的控制表达式；whileor do语句的控制表达式；for语句的每个（可选）表达式；return语句中的（可选）表达式。完整表达式的结尾是一个序列点。

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

• 初始化以初始化列表的顺序执行。

  6.7.8初始化

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

   

  19. 初始化应按初始化器列表顺序进行，为特定子对象提供的每个初始化器都将覆盖先前为同一子对象列出的所有初始化器；所有未明确初始化的子对象都应与具有静态存储持续时间的对象隐式初始化。

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

  6.7.8初始化

  23. 未指定初始化列表表达式中任何副作用发生的顺序。

但是，这仍然有一些问题无法解答：

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

  6.5表达式

  2. 在上一个序列点与下一个序列点之间，对象的存储值最多只能通过对表达式的求值来修改。此外，先验值应只读以确定要存储的值。

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

  这与附件J有点矛盾：

  J.2未定义行为

  • 在两个序列点之间，一个对象被修改一次以上，或者被修改，并且除了确定要存储的值之外，还读取先前的值（6.5）。

  附件J列出了所有修饰计数，而不仅仅是表达式修饰。但是鉴于附件是非规范性的，我们可能会忽略这一点。

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

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

1. a当输入for的存储块时，将为其分配存储空间。此时的内容不确定。
2. （仅）初始化程序被执行（a[2] = 1），后跟序列点。此店1在a[2]和回报1。
3. 那1用于初始化a[0]（第一个初始化器初始化第一个子对象）。

但在这里事情变得模糊，因为剩余的元素（a[1]，a[2]，a[3]，a[4]），都应该被初始化0，但是当它目前还不清楚：是否之前发生的a[2] = 1评价？如果是这样，a[2] = 1“ win”和overwrite a[2]会不会被覆盖，但是该赋值是否具有未定义的行为，因为在零初始化和赋值表达式之间没有序列点？序列点是否相关（请参见上文）？还是在对所有初始化程序求值后进行零初始化？如果是这样，a[2]最终应该是0。

因为C标准没有明确定义此处发生的情况，所以我认为行为是不确定的（忽略）。

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

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

来自N2176（C17草案）：

6.7.9初始化

23. 初始化列表表达式的求值相对于彼此不确定地排序，因此未指定发生任何副作用的顺序。 ^154）

因此，似乎输出1 0 0 0 0也是可能的。

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

我认为C11标准涵盖了这种行为，并表示结果未指定，而且我认为C18在此方面没有进行任何相关更改。

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

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初始化应按初始化器列表顺序进行，为特定子对象提供的每个初始化器都将覆盖先前为该子对象列出的所有初始化器；^151） 所有未明确初始化的子对象应与具有静态存储持续时间的对象隐式初始化。

^151）被覆盖的子对象的任何初始化程序，因此不用于初始化该子对象的初始化程序可能根本不会被评估。

另一个关键段落是：

§23初始化列表表达式的求值相对于彼此是不确定的，因此未指定发生任何副作用的顺序。^152）

^152）特别地，评估顺序不必与子对象初始化的顺序相同。

我很确定第23段指出了问题中的符号：

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

导致未指明的行为。对的赋值a[2]是一种副作用，并且表达式的求值顺序不确定地相对于彼此排序。因此，我认为没有一种方法可以诉诸该标准，并声称某个特定的编译器正在正确或不正确地处理此问题。

我的理解是 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;

我尝试给出一个简短而简单的答案： 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

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

我相信，这int a[5]={ a[2]=1 };是程序员将自己射入自己的脚的一个很好的例子。

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

在您真正真正想要的罕见情况下，int a[5]={ 1 }; a[2]=1;那将是一种有趣的编写方式。无论如何，这就是您的代码归结为的内容，即使此处有人指出，在a[2]实际执行写入操作时并没有很好地定义它。这里的陷阱是它a[2]=1不是一个指定的初始化程序，而是一个简单的赋值本身，赋值为1。