你的问题可能不是“为什么这些构念在C语言中是未定义的行为?”你的问题可能是，“为什么这段代码(使用++)没有给我预期的值?”，有人将你的问题标记为重复，并将你发送到这里。

这个答案试图回答这个问题:为什么您的代码没有给您预期的答案，以及您如何学会识别(和避免)不能按预期工作的表达式。

我假设您已经听说了C的c++和——操作符的基本定义，以及前缀形式++x与后缀形式x++的区别。但是这些运算符很难理解，所以为了确保你理解了，也许你写了一个很小的测试程序，涉及到

int x = 5;
printf("%d %d %d\n", x, ++x, x++);

但是，让你惊讶的是，这个程序并没有帮助你理解——它输出了一些奇怪的、无法解释的输出，这表明++可能做了一些完全不同的事情，完全不是你想的那样。

或者，也许你正在看到一个难以理解的表达，比如

int x = 5;
x = x++ + ++x;
printf("%d\n", x);

也许有人把代码作为谜题给你。这段代码也没有意义，特别是在运行它的时候——如果在两个不同的编译器下编译和运行它，可能会得到两个不同的答案!这是怎么回事?哪个答案是正确的?(答案是两者都是，或者都不是。)

正如您现在所听到的，这些表达式是未定义的，这意味着C语言不能保证它们将做什么。这是一个奇怪而令人不安的结果，因为您可能认为您可以编写的任何程序，只要它编译并运行，就会生成一个唯一的、定义良好的输出。但在未定义行为的情况下，就不是这样了。

什么使表达式没有定义?包含++和——的表达式总是未定义的吗?当然不是:这些都是有用的运算符，如果使用得当，它们的定义是完美的。

对于我们正在讨论的表达式，当同时发生太多事情时，当我们无法说出事情发生的顺序，但当顺序对我们得到的结果很重要时，它们就没有定义了。

让我们回到我在这个回答中使用的两个例子。当我写的时候

printf("%d %d %d\n", x, ++x, x++);

the question is, before actually calling printf, does the compiler compute the value of x first, or x++, or maybe ++x? But it turns out we don't know. There's no rule in C which says that the arguments to a function get evaluated left-to-right, or right-to-left, or in some other order. So we can't say whether the compiler will do x first, then ++x, then x++, or x++ then ++x then x, or some other order. But the order clearly matters, because depending on which order the compiler uses, we'll clearly get a different series of numbers printed out.

那么这个疯狂的表达呢?

x = x++ + ++x;

The problem with this expression is that it contains three different attempts to modify the value of x: (1) the x++ part tries to take x's value, add 1, store the new value in x, and return the old value; (2) the ++x part tries to take x's value, add 1, store the new value in x, and return the new value; and (3) the x = part tries to assign the sum of the other two back to x. Which of those three attempted assignments will "win"? Which of the three values will actually determine the final value of x? Again, and perhaps surprisingly, there's no rule in C to tell us.

You might imagine that precedence or associativity or left-to-right evaluation tells you what order things happen in, but they do not. You may not believe me, but please take my word for it, and I'll say it again: precedence and associativity do not determine every aspect of the evaluation order of an expression in C. In particular, if within one expression there are multiple different spots where we try to assign a new value to something like x, precedence and associativity do not tell us which of those attempts happens first, or last, or anything.

---

有了这些背景知识和介绍，如果你想确保你所有的程序都是定义良好的，哪些表达式可以写，哪些表达式不能写?

这些表达都不错:

y = x++;
z = x++ + y++;
x = x + 1;
x = a[i++];
x = a[i++] + b[j++];
x[i++] = a[j++] + b[k++];
x = *p++;
x = *p++ + *q++;

这些表达式都是未定义的:

x = x++;
x = x++ + ++x;
y = x + x++;
a[i] = i++;
a[i++] = i;
printf("%d %d %d\n", x, ++x, x++);

最后一个问题是，你如何分辨哪些表达式是定义良好的，哪些表达式是未定义的?

就像我之前说的，未定义表达式是那些同时有太多事情发生的表达式，你不能确定事情发生的顺序，以及顺序在哪里很重要:

如果有一个变量在两个或多个不同的地方被修改(赋值给)，您如何知道哪个修改先发生? 如果有一个变量在一个地方被修改，而它的值在另一个地方被使用，你怎么知道它使用的是旧值还是新值?

以#1为例，在表达式中

x = x++ + ++x;

有三次修改x的尝试。

作为#2的例子，在表达式中

y = x + x++;

我们都使用x的值，并修改它。

所以这就是答案:确保在您编写的任何表达式中，每个变量最多被修改一次，如果一个变量被修改，您也不要试图在其他地方使用该变量的值。

---

还有一件事。您可能想知道如何“修复”我在回答这个问题时提出的未定义表达式。

在printf("%d %d %d\n"， x， ++x, x++);的情况下，这很简单-只需将它写成三个独立的printf调用:

printf("%d ", x);
printf("%d ", ++x);
printf("%d\n", x++);

现在行为已经完全定义好了，您将得到合理的结果。

另一方面，在x = x++ + ++x的情况下，没有办法修复它。没有办法编写它来保证它的行为符合您的期望——但这没关系，因为无论如何在实际程序中都不会编写像x = x++ + ++x这样的表达式。

这种行为实际上无法解释，因为它同时调用了未指定的行为和未定义的行为，所以我们不能对这段代码做出任何一般的预测，尽管如果你阅读了Olve Maudal的著作，比如《Deep C》和《未指定的和未定义的》，有时你可以用特定的编译器和环境在非常特定的情况下做出很好的猜测，但请不要在生产环境附近这样做。

所以我们继续讨论未指明的行为，在c99标准草案第6.5节第3段说(我的重点):

操作符和操作数的分组由语法表示。除非指定 稍后(对于函数call()、&&、||、?:和逗号操作符)，子表达式的求值顺序和副作用发生的顺序都未指定。

所以当我们有一条这样的直线

i = i++ + ++i;

我们不知道是i++还是++i先被求值。这主要是为了给编译器提供更好的优化选项。

这里也有未定义的行为，因为程序在序列点之间不止一次地修改变量(i, u等)。标准草案第6.5节第2段(重点):

在前一个序列点和下一个序列点之间，一个对象应该有它的存储值 由表达式求值最多修改一次。此外，先验值 应该是只读的，以确定要存储的值。

它引用了以下未定义的代码示例:

i = ++i + 1;
a[i++] = i; 

在所有这些示例中，代码都试图在同一序列point中多次修改一个对象，该序列point将以;在以下每一种情况下:

i = i++ + ++i;
^   ^       ^

i = (i++);
^    ^

u = u++ + ++u;
^   ^       ^

u = (u++);
^    ^

v = v++ + ++v;
^   ^       ^

在c99标准草案第3.4.4节中，未指定的行为定义为:

使用未指定的值，或本标准规定的其他行为 两种或两种以上的可能性，并且对选择哪一种没有进一步的要求 实例

而未定义的行为在3.4.3节中定义为:

在使用不可移植的或错误的程序构造或错误的数据时， 本标准对此没有任何要求

并指出:

可能的未定义行为包括:完全忽略带有不可预测结果的情况，在翻译或程序执行期间以环境特征的文档化方式(有或没有发出诊断消息)行为，以及终止翻译或执行(发出诊断消息)。

我认为C99标准的相关部分是6.5表达式，§2

在前一个序列点和下一个序列点之间，一个对象应该有它的存储值 由表达式求值最多修改一次。此外，先验值 应该是只读的，以确定要存储的值。

和6.5.16赋值操作符，§4:

操作数的求值顺序未指定。如果试图修改 赋值运算符的结果或在下一个序列点之后访问它的结果 行为是未定义的。

原因是程序正在运行未定义的行为。问题在于求值顺序，因为根据c++ 98标准不需要序列点(根据c++ 11术语，没有任何操作在另一个操作之前或之后排序)。

然而，如果你坚持使用一个编译器，你会发现这种行为是持久的，只要你不添加函数调用或指针，这将使行为更加混乱。

使用Nuwen MinGW 15 GCC 7.1你会得到:

 #include<stdio.h>
 int main(int argc, char ** argv)
 {
    int i = 0;
    i = i++ + ++i;
    printf("%d\n", i); // 2

    i = 1;
    i = (i++);
    printf("%d\n", i); //1

    volatile int u = 0;
    u = u++ + ++u;
    printf("%d\n", u); // 2

    u = 1;
    u = (u++);
    printf("%d\n", u); //1

    register int v = 0;
    v = v++ + ++v;
    printf("%d\n", v); //2
 }

How does GCC work? it evaluates sub expressions at a left to right order for the right hand side (RHS) , then assigns the value to the left hand side (LHS) . This is exactly how Java and C# behave and define their standards. (Yes, the equivalent software in Java and C# has defined behaviors). It evaluate each sub expression one by one in the RHS Statement in a left to right order; for each sub expression: the ++c (pre-increment) is evaluated first then the value c is used for the operation, then the post increment c++).

根据GCC c++:操作符

在GCC c++中，操作符的优先级控制在 哪些操作符被求值

GCC所理解的定义行为c++中的等效代码:

#include<stdio.h>
int main(int argc, char ** argv)
{
    int i = 0;
    //i = i++ + ++i;
    int r;
    r=i;
    i++;
    ++i;
    r+=i;
    i=r;
    printf("%d\n", i); // 2

    i = 1;
    //i = (i++);
    r=i;
    i++;
    i=r;
    printf("%d\n", i); // 1

    volatile int u = 0;
    //u = u++ + ++u;
    r=u;
    u++;
    ++u;
    r+=u;
    u=r;
    printf("%d\n", u); // 2

    u = 1;
    //u = (u++);
    r=u;
    u++;
    u=r;
    printf("%d\n", u); // 1

    register int v = 0;
    //v = v++ + ++v;
    r=v;
    v++;
    ++v;
    r+=v;
    v=r;
    printf("%d\n", v); //2
}

然后我们去Visual Studio。Visual Studio 2015，你得到:

#include<stdio.h>
int main(int argc, char ** argv)
{
    int i = 0;
    i = i++ + ++i;
    printf("%d\n", i); // 3

    i = 1;
    i = (i++);
    printf("%d\n", i); // 2 

    volatile int u = 0;
    u = u++ + ++u;
    printf("%d\n", u); // 3

    u = 1;
    u = (u++);
    printf("%d\n", u); // 2 

    register int v = 0;
    v = v++ + ++v;
    printf("%d\n", v); // 3 
}

Visual Studio是如何工作的，它采用了另一种方法，它在第一遍计算所有的前增量表达式，然后在第二遍操作中使用变量值，在第三遍将RHS赋值给LHS，然后在最后一遍计算所有的后增量表达式。

因此，在定义行为的c++中，就像Visual c++理解的那样:

#include<stdio.h>
int main(int argc, char ** argv)
{
    int r;
    int i = 0;
    //i = i++ + ++i;
    ++i;
    r = i + i;
    i = r;
    i++;
    printf("%d\n", i); // 3

    i = 1;
    //i = (i++);
    r = i;
    i = r;
    i++;
    printf("%d\n", i); // 2 

    volatile int u = 0;
    //u = u++ + ++u;
    ++u;
    r = u + u;
    u = r;
    u++;
    printf("%d\n", u); // 3

    u = 1;
    //u = (u++);
    r = u;
    u = r;
    u++;
    printf("%d\n", u); // 2 

    register int v = 0;
    //v = v++ + ++v;
    ++v;
    r = v + v;
    v = r;
    v++;
    printf("%d\n", v); // 3 
}

如Visual Studio文档在优先级和计算顺序中所述:

当几个运算符同时出现时，它们具有相同的优先级，并根据它们的结合性进行计算。表中的操作符在以后缀操作符开头的部分中描述。

C标准规定，一个变量最多只能在两个序列点之间赋值一次。例如，分号是一个序列点。 所以每个形式的表述

i = i++;
i = i++ + ++i;

等等都违反了这个规则。该标准还说行为是未定义的，而不是未指定的。一些编译器确实检测这些并产生一些结果，但这不是每个标准。

但是，两个不同的变量可以在两个序列点之间递增。

while(*src++ = *dst++);

以上是在复制/分析字符串时常见的编码实践。

这个问题通常是与代码相关的问题的重复链接，比如

printf("%d %d\n", i, i++);

or

printf("%d %d\n", ++i, i++);

或者类似的变体。

虽然正如前面所述，这也是未定义的行为，但当涉及printf()时，与如下语句进行比较时，会有细微的差异:

x = i++ + i++;

---

在以下声明中:

printf("%d %d\n", ++i, i++);

printf()中参数的求值顺序未指定。这意味着，表达式i++和++i可以以任何顺序求值。C11标准对此有一些相关的描述:

附件J，未指明的行为

函数指示符、参数和 参数中的子表达式在函数调用中求值 (6.5.2.2)。

3.4.4，未指定的行为

使用未指定的值，或其他行为 国际标准提供了两种或两种以上的可能性 在任何情况下都没有进一步的要求。 未指定的行为的一个例子是 函数的参数被求值。

未指定的行为本身不是问题。想想这个例子:

printf("%d %d\n", ++x, y++);

这也具有未指定的行为，因为++x和y++的求值顺序是未指定的。但这是完全合法有效的声明。在这个语句中没有未定义的行为。因为修改(++x和y++)是对不同的对象进行的。

是什么呈现下面的语句

printf("%d %d\n", ++i, i++);

作为未定义的行为是这两个表达式修改相同的对象I没有中间序列点的事实。

---

另一个细节是printf()调用中涉及的逗号是分隔符，而不是逗号操作符。

这是一个重要的区别，因为逗号操作符确实在它们的操作数求值之间引入了一个序列点，这使得以下行为合法:

int i = 5;
int j;

j = (++i, i++);  // No undefined behaviour here because the comma operator 
                 // introduces a sequence point between '++i' and 'i++'

printf("i=%d j=%d\n",i, j); // prints: i=7 j=6

逗号操作符从左到右计算其操作数，只产生最后一个操作数的值。所以在j = (++i, i++);中，++i将i增加到6,i++产生i(6)的旧值，该值被分配给j。然后由于后增量，i变成7。

如果函数调用中的逗号是逗号操作符，那么

printf("%d %d\n", ++i, i++);

不会有问题的。但是它调用了未定义的行为，因为这里的逗号是分隔符。

---

对于那些不熟悉未定义行为的人来说，阅读《每一个C程序员都应该知道关于未定义行为的事情》可以帮助他们理解C语言中未定义行为的概念和许多其他变体。

本文:未定义、未指定和实现定义的行为也是相关的。