18

当我在下面初始化数组时，所有输出看起来都很好，除了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
4

5 回答 5

16

看起来您在这里受到未指定行为的影响，因为初始化列表表达式的评估顺序未指定，来自草案 C99 标准部分6.7.8：

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

注释 133 说：

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

据我所知，支持注释的规范文本133将来自部分6.5：

除非稍后指定 [...] 子表达式的求值顺序和副作用发生的顺序都是未指定的。

我们可以看到初始化6.8器是（强调我的）的完整表达式：

完整表达式是不属于另一个表达式或声明符的表达式。 下面的每一个都是一个完整的表达式：一个初始化器；[...]

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

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

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

我现在相信像 C++ 一样，完整表达式适用于初始化器列表中的每个初始化器，这使我之前的分析不正确。

缺陷报告 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如果在将 in 中的各个元素分配给之前评估以下表达式，则会出现未定义的行为：

 values[0] + values[5]

或者：

 values[5]/10

这是未定义的行为，因为使用不确定的值会调用未定义的行为。

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

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

还有其他替代方法，例如在初始化之后对元素3进行分配。9

于 2015-03-02T15:56:11.607 回答
7

这与指定的初始化程序本身无关。这与您在尝试这样的事情时遇到的错误相同：

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];
  ...

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

于 2015-03-02T16:01:35.510 回答
5

这是我第一次看到以这种方式初始化的东西，但我认为您看到的行为与访问尚未初始化的数组片段有关。所以我在 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

我在上面的输出中确定了一个关键行，我认为它标志着你生成的和我生成的之间的区别（标记为 <======）。在使用您指定的值初始化特定数组元素之前，我的是将数组的内容归零。数组元素的具体初始化发生在这之后。

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

希望这可以帮助。

于 2015-03-02T16:03:23.050 回答
4 
int values[10] = { 
    [0]=197,[2]=-100,[5]=350,
    [3]=values[0] + values[5],
    [9]= values[5]/10
};

编辑：

ISO C99 标准第6.7.8 节（初始化）指定

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

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

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

  • values[0]
  • values[5]（这就是你的情况）
  • 两个都
  • 他们都没有
于 2015-03-02T15:53:59.790 回答
1

试试这个代码：

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

然后像以前一样打印数组。

于 2015-03-02T16:13:21.880 回答