赋值操作符可以重载，在这种情况下，顺序可能很重要:

struct A {
    bool first;
    A () : first (false) {
    }
    const A & operator = (int i) {
        first = !first;
        return * this;
    }
};

void f (A a1, A a2) {
    // ...
}


// ...
A i;
f (i = -1, i = -1);   // the argument evaluated first has ax.first == true

令人困惑的是，将一个常量值存储到一个局部变量中并不是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或指针这样的类型(参见c++中的标量对象是什么?)

其次，似乎更明显的是

f(++i, ++i);

会有未定义的行为。但

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

不太明显。

一个稍微不同的例子:

int i;
f(i = 1, i = -1);
std::cout << i << "\n";

最后发生了什么赋值，i = 1，还是i = -1?标准中没有定义。实际上，这意味着i可能是5(请参阅harmic的答案，以获得完全合理的解释)。或者您的程序可以段错误。或者重新格式化你的硬盘。

但现在你会问:“那我的例子呢?两次赋值都使用相同的值(-1)。还有什么不清楚的呢?”

你说得对……除了c++标准委员会描述的方式。

如果一个标量对象上的副作用相对于同一标量对象上的另一个副作用没有排序，则该行为是未定义的。

他们本可以为你的特殊情况破例，但他们没有。(他们为什么要这么做呢?那又有什么用呢?)所以i仍然可以是5。或者你的硬盘可能是空的。因此，你问题的答案是:

它是未定义的行为，因为它没有定义行为是什么。

(这一点值得强调，因为许多程序员认为“未定义”意味着“随机”或“不可预测”。它不;它意味着不是由标准定义的。行为可能是100%一致的，但仍然没有定义。)

它可以被定义为行为吗?是的。它被定义了吗?不。因此，它是“未定义的”。

也就是说，“未定义”并不意味着编译器会格式化你的硬盘…这意味着它可以并且仍然是一个标准兼容的编译器。实际上，我确信g++、Clang和MSVC都能达到您的预期。他们只是“不必”。

另一个不同的问题可能是，为什么c++标准委员会选择不对这种副作用进行排序?这个答案将涉及历史和委员会的意见。或者在c++中没有对副作用进行排序有什么好处?，这就允许任何理由，不管它是否是标准委员会的实际推理。你可以在这里或programmers.stackexchange.com上问这些问题。

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

// 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的常量表达式是不允许的，这会导致编译失败。因此，改变一个常量可能会在其他地方导致编译错误。恕我直言，这很不幸。但是，将这些事情限制在不可避免的范围内当然是好的。

这只是回答了“我不确定“标量对象”可能意味着什么，除了像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。

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