First of all, in fact, it has been clearly stated above that writing such code is very irresponsible. But since we want to discuss it, let’s discuss this issue in a discussion way. The code I tested is not complicated, just the following lines:

#include <stdio.h>
int main()
{
    int a=0,b=0;
    a = 10;
    b = a+++a++;
    printf("%d %d\n", b, a);
    return 0;
}

Compiler: gcc version 4.9.2 (Raspbian 4.9.2-10)
Output result:

21 12

Let’s first discuss the equivalent situation of a+++a++. According to the C language operator priority, postfix ++ has a higher priority than +, that is, a+++a++ can in principle be equivalent to (a++)+(a++). So, how does the compiler understand it? It understands it as a syntax tree, something like this:

        +
       / \
      /   \
    a++   a++

• 1. Process the first

  a++ operation: Because it is a post-position operation, a (at this time a=10) is pushed onto the stack, and then a=a+1, now a is 11;

• 2. Process the second

  a++ operation: the same, first push a (at this time a=11) onto the stack, and then a= a+1, now a is 12;

• 3. Process the

  + (sum) operation: Because + is a binary operation (that is, an operation that requires two operands), first pop the two operands from the stack, That is, 10 and 11 just pushed onto the stack, and then do the + operation, that is, 10+11, and the final result is 21.

• push(a), a onto stack(10)

• a=a+1, a plus 1

• push(a), a onto stack(11)

• a=a+1, a plus 1

• b=pop()+pop(), add the two operands (10,11) from the stack and assign the value to b(=21)

In the stack-based processing method, the operands are popped from the stack and then operated (of course, the data in the stack was also pushed in before), instead of directly using a to calculate, modern compilers are basically implemented based on the stack method. I guess this is where your doubts lie. If you want to know more, you can read about Compilation Principles.

(a++)+(a++) In gcc4.5.1, I finally got 20. In my hand There is no 4.5.1, but 21 is obtained on 4.9.2 and 4.2.1, and different optimization levels have been tried. If true, it may be other options or a problem between versions.

As I said before, try to write code that is easy for people to understand.

If you test it with different compilers, you will find that the results are different from your current results. Or if you change the compilation parameters under the same compiler, the results will be different. In the final analysis, this type of problem is undefined behavior. Therefore, what you have to remember is not when i will be added, but to ensure that you do not write such garbage code. .

The questioner can take a look at this
[] (https://en.m.wikipedia.org/wiki/Undefined_behavior)
Construct the same object between two sequence points Two modifications are undefined behavior and unpredictable

standard C is not defined
The compiler handles it by itself according to its own rules.

Teacher Qiu Zongyan has already given a complete answer to this question.

Back to the previous example: "Who knows what value is assigned to n in the following C statement?"

m = 1; n = m++ +m++;

The correct answer is: I don’t know! The language does not specify what it should calculate, and the results completely depend on the specific processing of the specific system in the specific context. This involves the order of evaluation of the operands and the implementation time of variable modification.

http://www.math.pku.edu.cn/teachers/qiuzy/technotes/expression2009.pdf

Undefined behavior.

Compiler implementations are different because ++ has an impact, and the time at which the compiler eliminates the impact is different.

This kind of question makes no sense. This kind of statement cannot appear in your code at all

I remembered an article I read before, which is similar to your question.
Link

No matter what, it is best to use concise and easy-to-understand statements as much as possible in the project, and avoid such code that does not know what strange problems will occur.

First of all, I admire the author’s spirit of exploration.
But I suggest you take a look:

1. Priority of C language operators

2. Associativity of C language operators

As if that’s not enough, let’s take a look at the detailed semantic description of the relevant operators in the C language specification:

http://eli-project.sourceforge.net/c_html/c.html

It doesn’t seem to work, so we can only look at the implementation of the compiler.

This seems to be related to the compiler. In fact, when you understand it, you can understand it like this: i++ => b = i; i = i + 1; and then the return value of I++ is b, so you can understand it this way. Some compilers return i, then i = i + 1;