虽然任何编译器和处理器实际上都不太可能这样做，但在C标准下，编译器使用以下序列实现"i++"是合法的:

In a single operation, read `i` and lock it to prevent access until further notice
Compute (1+read_value)
In a single operation, unlock `i` and store the computed value

虽然我不认为有任何处理器支持这样的硬件，可以有效地完成这样的事情，人们可以很容易地想象这样的行为会使多线程代码更容易(例如，它将保证如果两个线程同时尝试执行上面的序列，I将增加2)，而且未来的某些处理器可能会提供类似的功能，这并不是完全不可想象的。

If the compiler were to write i++ as indicated above (legal under the standard) and were to intersperse the above instructions throughout the evaluation of the overall expression (also legal), and if it didn't happen to notice that one of the other instructions happened to access i, it would be possible (and legal) for the compiler to generate a sequence of instructions that would deadlock. To be sure, a compiler would almost certainly detect the problem in the case where the same variable i is used in both places, but if a routine accepts references to two pointers p and q, and uses (*p) and (*q) in the above expression (rather than using i twice) the compiler would not be required to recognize or avoid the deadlock that would occur if the same object's address were passed for both p and q.

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

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

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

你最有趣的例子就是

u = (u++);

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

虽然像a = a++或a++ + a++这样的表达式的语法是合法的，但这些结构的行为是未定义的，因为在C标准中不遵守shall。C99 6.5 p2:

在前一个序列点和下一个序列点之间，通过表达式求值，对象的存储值最多修改一次。[72]此外，前面的值只能被读取，以确定要存储的值[73]

脚注73进一步澄清

本段给出了未定义的语句表达式，如 I = ++ I + 1; A [i++] = i; 同时允许 I = I + 1; A [i] = i;

各序列点列于C11(和C99)的附件C:

The following are the sequence points described in 5.1.2.3: Between the evaluations of the function designator and actual arguments in a function call and the actual call. (6.5.2.2). Between the evaluations of the first and second operands of the following operators: logical AND && (6.5.13); logical OR || (6.5.14); comma , (6.5.17). Between the evaluations of the first operand of the conditional ? : operator and whichever of the second and third operands is evaluated (6.5.15). The end of a full declarator: declarators (6.7.6); Between the evaluation of a full expression and the next full expression to be evaluated. The following are full expressions: an initializer that is not part of a compound literal (6.7.9); the expression in an expression statement (6.8.3); the controlling expression of a selection statement (if or switch) (6.8.4); the controlling expression of a while or do statement (6.8.5); each of the (optional) expressions of a for statement (6.8.5.3); the (optional) expression in a return statement (6.8.6.4). Immediately before a library function returns (7.1.4). After the actions associated with each formatted input/output function conversion specifier (7.21.6, 7.29.2). Immediately before and immediately after each call to a comparison function, and also between any call to a comparison function and any movement of the objects passed as arguments to that call (7.22.5).

C11同一段的措词是:

如果标量对象上的副作用相对于同一标量对象上的不同副作用或使用同一标量对象的值进行的值计算没有排序，则行为未定义。如果一个表达式的子表达式有多个允许的顺序，那么如果这种未排序的副作用出现在任意一个顺序中，则该行为是未定义的。

---

您可以在程序中检测此类错误，例如使用带有-Wall和-Werror的最新版本的GCC，然后GCC将直接拒绝编译您的程序。gcc (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005的输出如下:

% gcc plusplus.c -Wall -Werror -pedantic
plusplus.c: In function ‘main’:
plusplus.c:6:6: error: operation on ‘i’ may be undefined [-Werror=sequence-point]
    i = i++ + ++i;
    ~~^~~~~~~~~~~
plusplus.c:6:6: error: operation on ‘i’ may be undefined [-Werror=sequence-point]
plusplus.c:10:6: error: operation on ‘i’ may be undefined [-Werror=sequence-point]
    i = (i++);
    ~~^~~~~~~
plusplus.c:14:6: error: operation on ‘u’ may be undefined [-Werror=sequence-point]
    u = u++ + ++u;
    ~~^~~~~~~~~~~
plusplus.c:14:6: error: operation on ‘u’ may be undefined [-Werror=sequence-point]
plusplus.c:18:6: error: operation on ‘u’ may be undefined [-Werror=sequence-point]
    u = (u++);
    ~~^~~~~~~
plusplus.c:22:6: error: operation on ‘v’ may be undefined [-Werror=sequence-point]
    v = v++ + ++v;
    ~~^~~~~~~~~~~
plusplus.c:22:6: error: operation on ‘v’ may be undefined [-Werror=sequence-point]
cc1: all warnings being treated as errors

重要的部分是知道什么是序列点，什么是序列点，什么不是。例如，逗号操作符是一个序列点，所以

j = (i ++, ++ i);

定义良好，并将I加1，得到旧值，丢弃旧值;然后在逗号运算符，解决副作用;然后将I加1，结果值就变成了表达式的值——也就是说，这只是一种写j = (I += 2)的人为方法，这也是一种“聪明”的写法

i += 2;
j = i;

然而，函数参数列表中的，不是逗号操作符，并且在不同参数的计算之间没有序列点;相反，他们对彼此的评价是没有顺序的;函数调用

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

具有未定义的行为，因为在函数参数中i++和++i的计算之间没有序列点，因此i的值在前一个序列点和下一个序列点之间被i++和++i修改了两次。

原因是程序正在运行未定义的行为。问题在于求值顺序，因为根据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文档在优先级和计算顺序中所述:

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

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

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语言中未定义行为的概念和许多其他变体。

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

这里的大多数答案都引用自C标准，强调这些构造的行为是未定义的。为了理解为什么这些结构的行为是未定义的，让我们先从C11标准的角度来理解这些术语:

测序(5.1.2.3):

给定任意两个评估A和B，如果A排在B之前，则A的执行应先于B的执行。

Unsequenced:

如果A不在B之前或之后测序，则A和B是未测序的。

评估可能是以下两种情况之一:

值计算，计算出表达式的结果;而且 副作用，也就是对对象的修改。

序列:

在表达式a和表达式B的求值之间存在序列点，意味着与a相关的每个值计算和副作用都在与B相关的每个值计算和副作用之前排序。

现在回到问题，对于像这样的表达

int i = 1;
i = i++;

标准说:

6.5表达式:

如果标量对象上的副作用相对于同一标量对象上的不同副作用或使用同一标量对象的值进行的值计算没有排序，则行为未定义。[…]

因此，上面的表达式调用UB，因为同一对象i上的两个副作用彼此之间没有顺序。这意味着赋值给i的副作用是在++的副作用之前还是之后，没有排序。 根据赋值是发生在增量之前还是之后，将产生不同的结果，这就是未定义行为的情况之一。

将赋值左边的i重命名为il，赋值右边(表达式i++)重命名为ir，则表达式为

il = ir++     // Note that suffix l and r are used for the sake of clarity.
              // Both il and ir represents the same object.  

关于postfix++操作符的重要一点是:

仅仅因为++出现在变量之后并不意味着增量发生得晚。只要编译器确保使用原始值，增量可以在编译器喜欢的时间发生。

这意味着表达式il = ir++可以被求值为

temp = ir;      // i = 1
ir = ir + 1;    // i = 2   side effect by ++ before assignment
il = temp;      // i = 1   result is 1  

or

temp = ir;      // i = 1
il = temp;      // i = 1   side effect by assignment before ++
ir = ir + 1;    // i = 2   result is 2  

导致两个不同的结果1和2，这取决于通过赋值和++的副作用的顺序，因此调用UB。