为什么 f(i = -1, i = -1) 行为未定义？

由于操作是无序的，没有什么可以说执行分配的指令不能被交错。这样做可能是最佳选择，具体取决于 CPU 架构。引用的页面说明了这一点：

如果 A 没有在 B 之前排序并且 B 没有在 A 之前排序，则存在两种可能性： A 和 B 的评估是未排序的：它们可以以任何顺序执行并且可能重叠（在单个执行线程中，编译器可能交错包含 A 和 B 的 CPU 指令）对 A 和 B 的评估是不确定顺序的：它们可以按任何顺序执行但不能重叠：A 将在 B 之前完成，或者 B 将在 A 之前完成。顺序可以下一次计算相同的表达式时相反。

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

例如，想象一下将内存归零然后递减它比加载值 -1 更有效。然后：

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

可能变成：

clear i
clear i
decr i
decr i

现在我是-2。

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

首先，“标量对象”是指像 int、float 或指针这样的类型（参见 What is a scalar Object in 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 不再编译了。然而，我们认为编译不应该依赖于文字的值。

底线：该规则没有例外，因为它会使成功编译取决于常量的值（而不是类型）。

编辑

@HeartWare pointed out 当 B 为 0 时，某些语言中不允许使用 A DIV B 形式的常量表达式，这会导致编译失败。因此，更改常量可能会在其他地方导致编译错误。恕我直言，不幸的是。但是将这些事情限制在不可避免的情况下当然是好的。

令人困惑的是，将常量值存储到局部变量中并不是每个 C 设计运行的架构上的原子指令。在这种情况下，代码运行的处理器比编译器更重要。例如，在每条指令不能携带完整的 32 位常量的 ARM 上，将 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 但我的例子仍然有效，因为重要的是要考虑到即使是常数也可能不像看起来那么明显。

如果出于某种可以想象的原因，试图“帮助”的编译器可能会做一些会导致完全意想不到的行为的事情，那么行为通常被指定为未定义。

在一个变量被多次写入而没有确保写入发生在不同时间的情况下，某些种类的硬件可能允许使用双端口存储器同时对不同地址执行多个“存储”操作。但是，一些双端口存储器明确禁止两个存储同时访问相同地址的情况，无论写入的值是否匹配。如果此类机器的编译器注意到两次未排序的写入同一变量的尝试，它可能会拒绝编译或确保无法同时安排两次写入。但是，如果其中一个或两个访问是通过指针或引用进行的，编译器可能并不总是能够判断两个写入是否会命中相同的存储位置。在这种情况下，它可能会同时安排写入，从而导致访问尝试出现硬件陷阱。

当然，有人可能在这样的平台上实现 C 编译器这一事实并不意味着当使用足够小的类型存储以进行原子处理时，不应在硬件平台上定义这种行为。如果编译器没有意识到，试图以无序的方式存储两个不同的值可能会导致奇怪；例如，给定：

uint8_t v;  // Global

void hey(uint8_t *p)
{
  moo(v=5, (*p)=6);
  zoo(v);
  zoo(v);
}

如果编译器内联对“moo”的调用并且可以告诉它没有修改“v”，它可能会将 5 存储到 v，然后将 6 存储到 *p，然后将 5 传递给“zoo”，然后将 v 的内容传递给“动物园”。如果“zoo”没有修改“v”，那么这两个调用就不应该被传递不同的值，但这很容易发生。另一方面，如果两个存储都写入相同的值，则不会发生这种奇怪的情况，并且在大多数平台上，实现做任何奇怪的事情都没有合理的理由。不幸的是，除了“因为标准允许”之外，一些编译器编写者不需要任何愚蠢行为的借口，因此即使这些情况也不安全。

在 this 的情况下，大多数实现中的结果是相同的这一事实是偶然的；评估顺序仍未确定。考虑 f(i = -1, i = -2)：在这里，顺序很重要。在您的示例中无关紧要的唯一原因是两个值都是 -1。

鉴于表达式被指定为具有未定义行为的表达式，当您评估 f(i = -1, i = -1) 并中止执行时，恶意兼容的编译器可能会显示不适当的图像 - 并且仍然被认为是完全正确的。幸运的是，我所知道的编译器都没有这样做。

在我看来，与函数参数表达式排序有关的唯一规则在这里：

3) 在调用函数时（无论函数是否内联，以及是否使用显式函数调用语法），与任何参数表达式或与指定被调用函数的后缀表达式相关的每个值计算和副作用是在被调用函数主体中的每个表达式或语句执行之前排序。

这并没有定义参数表达式之间的顺序，所以我们最终在这种情况下：

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

实际上，在大多数编译器上，您引用的示例将运行良好（与“擦除硬盘”和其他理论上的未定义行为后果相反）。然而，这是一种责任，因为它取决于特定的编译器行为，即使两个分配的值相同。此外，显然，如果您尝试分配不同的值，结果将是“真正”未定义的：

void f(int l, int r) {
    return l < -1;
}
auto b = f(i = -1, i = -2);
if (b) {
    formatDisk();
}

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

赋值运算符可能会被重载，在这种情况下，顺序可能很重要：

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

这只是在回答“我不确定“标量对象”除了诸如 int 或 float 之类的东西之外还意味着什么”。

我会将“标量对象”解释为“标量类型对象”的缩写，或者只是“标量类型变量”。那么，pointer、enum（常数）是标量类型。

这是 Scalar Types 的 MSDN 文章。

实际上，有理由不依赖于编译器会检查 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)));
}