C有未定义行为的概念，也就是说，一些语言结构在语法上是有效的，但你不能预测代码运行时的行为。

据我所知，该标准并没有明确说明为什么存在未定义行为的概念。在我看来，这只是因为语言设计者想在语义上有一些余地，而不是要求所有实现以完全相同的方式处理整数溢出，这很可能会带来严重的性能损失，他们只是让行为未定义，所以如果你编写的代码导致整数溢出，任何事情都可能发生。

那么，考虑到这一点，为什么这些是“问题”呢?语言清楚地表明，某些事情会导致未定义的行为。没有什么问题，没有什么“应该”牵涉其中。如果当其中一个涉及的变量被声明为volatile时，未定义的行为发生了变化，这并不能证明或改变任何东西。它是没有定义的;你不能对这种行为进行推理。

你最有趣的例子就是

u = (u++);

是教科书上未定义行为的例子(见维基百科关于序列点的条目)。

只要编译和反汇编你的代码行，如果你如此倾向于知道它是如何得到你所得到的。

这是我从我的机器上得到的，以及我认为正在发生的事情:

$ cat evil.c
void evil(){
  int i = 0;
  i+= i++ + ++i;
}
$ gcc evil.c -c -o evil.bin
$ gdb evil.bin
(gdb) disassemble evil
Dump of assembler code for function evil:
   0x00000000 <+0>:   push   %ebp
   0x00000001 <+1>:   mov    %esp,%ebp
   0x00000003 <+3>:   sub    $0x10,%esp
   0x00000006 <+6>:   movl   $0x0,-0x4(%ebp)  // i = 0   i = 0
   0x0000000d <+13>:  addl   $0x1,-0x4(%ebp)  // i++     i = 1
   0x00000011 <+17>:  mov    -0x4(%ebp),%eax  // j = i   i = 1  j = 1
   0x00000014 <+20>:  add    %eax,%eax        // j += j  i = 1  j = 2
   0x00000016 <+22>:  add    %eax,-0x4(%ebp)  // i += j  i = 3
   0x00000019 <+25>:  addl   $0x1,-0x4(%ebp)  // i++     i = 4
   0x0000001d <+29>:  leave  
   0x0000001e <+30>:  ret
End of assembler dump.

(我…假设0x00000014指令是某种编译器优化?)

这种行为实际上无法解释，因为它同时调用了未指定的行为和未定义的行为，所以我们不能对这段代码做出任何一般的预测，尽管如果你阅读了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节中定义为:

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

并指出:

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

回答这个问题的另一种方法是，不要陷入序列点和未定义行为的神秘细节中，而是简单地问，它们应该是什么意思?程序员试图做什么?

第一个片段，i = i++ + ++i，在我的书中很明显是疯狂的。没有人会把它写进真正的程序中，它的功能并不明显，没有人会尝试编写的算法会导致这种特殊的人为操作序列。因为你我都不清楚它应该做什么，所以在我的书中，如果编译器不能弄清楚它应该做什么也没关系。

第二个片段i = i++比较容易理解。很明显，有人试图增加i，并将结果赋值回给i。但是在c中有几种方法可以做到这一点。将1加到i，并将结果赋值回给i，这在几乎任何编程语言中都是相同的:

i = i + 1

当然，C有一个方便的快捷方式:

i++

这意味着，“将1加到i，并将结果赋给i”。所以如果我们通过写作来构造一个两者的大杂烩

i = i++

我们真正说的是“给i加1，然后把结果赋给i，再把结果赋给i”我们感到困惑，所以如果编译器也感到困惑，也不会太困扰我。

实际上，只有当人们将这些疯狂的表达式用作c++应该如何工作的人为示例时，才会写出这些疯狂的表达式。当然，理解++的工作原理也很重要。但使用++的一个实际规则是，“如果使用++的表达式的含义不明显，就不要写它。”

我们曾经在comp.lang.c上花了无数个小时讨论这样的表达式以及为什么它们是未定义的。我的两个较长的回答，试图真正解释为什么，被存档在网络上:

为什么标准没有定义它们的作用? 运算符的优先级不是决定求值的顺序吗?

请参见问题3.8和C常见问题列表第三部分的其他问题。

我认为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文档在优先级和计算顺序中所述:

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