令人困惑的是，将一个常量值存储到一个局部变量中并不是C设计用于运行的每个架构上的一个原子指令。在这种情况下，运行代码的处理器比编译器更重要。例如，在ARM上，每条指令都不能携带一个完整的32位常量，在一个变量中存储一个int就需要更多的指令。这个伪代码的例子，你一次只能存储8位，并且必须在32位寄存器中工作，i是一个int32:

reg = 0xFF; // first instruction
reg |= 0xFF00; // second
reg |= 0xFF0000; // third
reg |= 0xFF000000; // fourth
i = reg; // last

你可以想象，如果编译器想要优化它，它可能会将相同的序列交叉两次，你不知道什么值会被写入i;假设他不太聪明

reg = 0xFF;
reg |= 0xFF00;
reg |= 0xFF0000;
reg = 0xFF;
reg |= 0xFF000000;
i = reg; // writes 0xFF0000FF == -16776961
reg |= 0xFF00;
reg |= 0xFF0000;
reg |= 0xFF000000;
i = reg; // writes 0xFFFFFFFF == -1

然而，在我的测试中，gcc足够友好，可以识别相同的值被使用了两次，并生成它一次，没有任何奇怪的事情。得到-1和-1 但我的例子仍然是有效的，因为重要的是要考虑到即使是常数也可能不像它看起来那么明显。

这只是回答了“我不确定“标量对象”可能意味着什么，除了像int或float这样的东西”。

我会将“标量对象”解释为“标量类型对象”的缩写，或者只是“标量类型变量”。然后，指针，enum(常量)是标量类型。

这是一篇关于标量类型的MSDN文章。

由于操作是无序的，因此执行赋值的指令不能交叉。这样做可能是最佳的，这取决于CPU架构。参考页面说明如下:

If A is not sequenced before B and B is not sequenced before A, then two possibilities exist: evaluations of A and B are unsequenced: they may be performed in any order and may overlap (within a single thread of execution, the compiler may interleave the CPU instructions that comprise A and B) evaluations of A and B are indeterminately-sequenced: they may be performed in any order but may not overlap: either A will be complete before B, or B will be complete before A. The order may be the opposite the next time the same expression is evaluated.

这本身似乎不会造成问题——假设正在执行的操作是将值-1存储到内存位置。但是，编译器不能将其优化为具有相同效果的单独指令集，但如果该操作与同一内存位置上的另一个操作交织在一起，则可能会失败。

例如，想象一下，与将值-1载入内存相比，先将内存归零，再将其递减更有效。那么这个:

f(i=-1, i=-1)

可能成为:

clear i
clear i
decr i
decr i

现在i是-2。

这可能是一个虚假的例子，但它是可能的。

c++ 17定义了更严格的求值规则。特别地，它对函数参数进行排序(尽管没有指定顺序)。

N5659§4.6:15 当A在B之前排序或B在A之前排序时，计算A和B是不确定排序的， 但没有说明是哪一种。[注意:不确定排序的计算不能重叠，但也可以重叠 先执行。-结束注释] N5659§8.2.2:5 的 参数的初始化，包括每个相关的值计算和副作用，都是不确定的 按任何其他参数的顺序排列。

它允许一些情况，之前是UB:

f(i = -1, i = -1); // value of i is -1
f(i = -1, i = -2); // value of i is either -1 or -2, but not specified which one

一个不因为两个值相同而从规则中例外的实际原因:

// config.h
#define VALUEA  1

// defaults.h
#define VALUEB  1

// prog.cpp
f(i = VALUEA, i = VALUEB);

考虑一下这种情况是允许的。

现在，几个月后，改变的需求出现了

 #define VALUEB 2

看起来是无害的，不是吗?然而突然prog.cpp就不能再编译了。 但是，我们认为编译不应该依赖于字面量的值。

底线:该规则没有例外，因为它将使成功的编译依赖于常量的值(而不是类型)。

EDIT

@ hearttware指出，在某些语言中，当B为0时，形式为A DIV B的常量表达式是不允许的，这会导致编译失败。因此，改变一个常量可能会在其他地方导致编译错误。恕我直言，这很不幸。但是，将这些事情限制在不可避免的范围内当然是好的。

实际上，不依赖于编译器会检查i是否被赋值两次的事实是有原因的，这样就可以用一次赋值替换它。如果我们有一些表达呢?

void g(int a, int b, int c, int n) {
    int i;
    // hey, compiler has to prove Fermat's theorem now!
    f(i = 1, i = (ipow(a, n) + ipow(b, n) == ipow(c, n)));
}