Question

当我初始化下面的数组时，除了values[3]之外，所有输出看起来都没问题。出于某种原因values[3]初始化为values[0]+values[5]输出的数字非常大。我的猜测是我试图在将values[0]+values[5]正确存储到内存之前进行分配，但是如果有人能够解释那就太好了。

int main (void)
{

    int values[10] = { 
        [0]=197,[2]=-100,[5]=350,
        [3]=values[0] + values[5],
        [9]= values[5]/10
    };

    int index;

    for (index=0; index<10; index++)
        printf("values[%i] = %i\n", index, values[index]);


    return 0;
}

输出如下：

values[0] = 197
values[1] = 0
values[2] = -100
values[3] = -1217411959
values[4] = 0
values[5] = 350
values[6] = 0
values[7] = 0
values[8] = 0
values[9] = 35

Answer 1

由于初始化列表表达式的评估顺序未在C99标准部分6.7.8草案中指定，因此您在此处受到未指定的行为约束：

初始化中出现任何副作用的顺序列表表达式未指定。^133）

并注释133说：

特别是，评估顺序不必与订单相同子对象初始化。

~~据我所知，备注注释133的规范性文本来自6.5部分：~~

除了后面指定的[...]评估顺序   子表达式和副作用发生的顺序都是   未指定的。

我们可以看到 intializer 是来自6.8的完整表达式（强调我的）：


完整表达式是不属于另一个表达式的表达式   表达或声明者。   以下各项均为完整表达式：初始化程序; [...]

回顾我的一个old C++ answers覆盖了初始化程序中的序列点并将完整表达式放在不同的地方然后我最初得出结论，我意识到了语法6.7.8包含初始化程序两次：

initializer:
    assignment-expression
    { initializer-list }
    { initializer-list , }
initializer-list:
    designationopt initializer
    initializer-list , designationopt initializer

我最初没有注意到这一点，并认为完整表达式上的语句应用于上述语法中的top元素。

我现在相信像C ++一样，完整表达式适用于初始化列表中的每个初始值设定项，这使我以前的分析不正确。< / p>

Defect report 439证实了我的怀疑，确实如此，它包含以下示例：

#include <stdio.h>

#define ONE_INIT      '0' + i++ % 3
#define INITIALIZERS      [2] = ONE_INIT, [1] = ONE_INIT, [0] = ONE_INIT

int main()
{
    int i = 0;
    char x[4] = { INITIALIZERS }; // case 1
    puts(x);
    puts((char [4]){ INITIALIZERS }); // case 2
    puts((char [4]){ INITIALIZERS } + i % 2); // case 3
}

它说：

在每次使用INITIALIZERS宏时，变量i都会递增三次。在案例1和案例2中，没有未定义的行为，因为增量位于不确定序列的表达式中相互之间，没有后悔。

所以INITIALIZERS中的每个初始值程序都是完整表达式。

由于此缺陷报告针对C11，因此值得注意的是C11在此问题的规范性文本中比C99更详细，它说：

初始化列表表达式的评估是不确定地相互之间进行排序，从而对发生任何副作用的顺序是未指定的。^152）

在将values中的各个元素分配给以下表达式之前评估以下表达式时，存在未定义的行为：

 values[0] + values[5]

或：

 values[5]/10

这是使用indeterminate value invokes undefined behavior时未定义的行为。

在这种特殊情况下，最简单的解决方法是手动执行计算：

int values[10] = { 
    [0]=197,[2]=-100,[5]=350,
    [3]= 197 + 350,
    [9]= 350/10
};

还有其他选择，例如在初始化后对元素3和9进行分配。

Answer 2

这与指定的初始化器无关。这与你在尝试这样的事情时得到的错误相同：

int array[10] = {5, array[0]};

执行初始化列表表达式的顺序只是未指定的行为。这意味着它是特定于编译器的，没有文档记录，永远不应该依赖：

C11 6.7.9 / 23

初始化列表表达式的评估是不确定地相互之间进行排序，从而对发生任何副作用的顺序是未指定的。

由于您使用数组项初始化其他数组成员，这意味着您必须将代码更改为运行时分配而不是初始化。

  int values[10];

  values[2] = -100;
  values[5] = 350;
  values[3] = values[0] + values[5];
  ...

作为副作用，您的程序现在也将更具可读性。

Answer 3

这是我第一次看到以这种方式初始化的东西，但我认为你所看到的行为与访问尚未初始化的数组有关。所以我在32位Ubuntu 12.04系统上使用GCC 4.6.3构建它。在我的环境中，我得到的结果与你不同。

gcc file.c -o file

./file
values[0] = 197
values[1] = 0
values[2] = -100
values[3] = 197
values[4] = 0
values[5] = 350
values[6] = 0
values[7] = 0
values[8] = 0
values[9] = 35


objdump -d file > file.asm

cat file.asm     (relevant portion posted below)

080483e4 <main>:
 80483e4:   55                      push   %ebp
 80483e5:   89 e5                   mov    %esp,%ebp
 80483e7:   57                      push   %edi
 80483e8:   53                      push   %ebx
 80483e9:   83 e4 f0                and    $0xfffffff0,%esp
 80483ec:   83 ec 40                sub    $0x40,%esp
 80483ef:   8d 5c 24 14             lea    0x14(%esp),%ebx
 80483f3:   b8 00 00 00 00          mov    $0x0,%eax
 80483f8:   ba 0a 00 00 00          mov    $0xa,%edx
 80483fd:   89 df                   mov    %ebx,%edi
 80483ff:   89 d1                   mov    %edx,%ecx
 8048401:   f3 ab                   rep stos %eax,%es:(%edi)   <=====
 8048403:   c7 44 24 14 c5 00 00    movl   $0xc5,0x14(%esp)
 804840a:   00 
 804840b:   c7 44 24 1c 9c ff ff    movl   $0xffffff9c,0x1c(%esp)
 8048412:   ff
 8048413:   8b 54 24 14             mov    0x14(%esp),%edx
 8048417:   8b 44 24 28             mov    0x28(%esp),%eax
 804841b:   01 d0                   add    %edx,%eax
 804841d:   89 44 24 20             mov    %eax,0x20(%esp)
 8048421:   c7 44 24 28 5e 01 00    movl   $0x15e,0x28(%esp)
 8048428:   00 
 8048429:   8b 4c 24 28             mov    0x28(%esp),%ecx
 804842d:   ba 67 66 66 66          mov    $0x66666667,%edx
 8048432:   89 c8                   mov    %ecx,%eax
 8048434:   f7 ea                   imul   %edx
 8048436:   c1 fa 02                sar    $0x2,%edx
 8048439:   89 c8                   mov    %ecx,%eax
 804843b:   c1 f8 1f                sar    $0x1f,%eax

我已经在上面的输出中找到了一个关键线，我认为这标志着你生成的和我生成的内容之间的区别（用＆lt; ======标记）。在使用您指定的值初始化特定数组元素之前，我正在将数组的内容归零。在此之后发生数组元素的特定初始化。

鉴于上述行为，我认为在初始化数组的特定元素之前假设你的数组内容没有归零是不合理的。至于为什么行为上的差异？我只能推测;但我的第一个猜测是我们使用两种不同的编译器版本。

希望这有帮助。

Answer 4

int values[10] = { 
    [0]=197,[2]=-100,[5]=350,
    [3]=values[0] + values[5],
    [9]= values[5]/10
};

<强> 编辑：

ISO C99 standard, section 6.7.8 (Initialization) 指定

初始化 应在初始化列表顺序 中发生初始化程序为特定的子对象提供覆盖任何子对象以前列出的同一子对象的初始值设定项; 132）全部未初始化的子对象应初始化与具有静态存储持续时间
的对象隐式相同

但正如Shafik指出的那样， 评估顺序不必与初始化顺序相匹配

这意味着values[0] + values[5]可以从以下位置读取垃圾值：

values[0]
values[5]（这就是你的情况）
both
没有人

Answer 5

试试这段代码：

int values[10];
values[0]=197;
values[2]=-100;
values[5]=350;
values[3]=values[0]+values[5];
values[9]=values[5]/10;

然后你像你一样打印阵列。

使用指定的初始值设定项初始化数组时的奇怪值

5 个答案: