May I ask about the autoincrement operator in C

+ Follow the right binding rule;

a=++i++;Equivalent to int temp=i++, a=++temp;

But temp is equivalent to a constant, and ++ cannot be applied to a constant, so this statement is wrong;

a=i+++i;Equivalent.

int temp=++i,a=i+++temp;But there are three + in the middle, and there is an objection to the combination, so this statement cannot be compiled.

a=++i+++i;Three + objections cannot be compiled;

int a,i=1;

a=i-++i;equivalent to int temp=++i,a=i-temp;

After execution, temp=2, i=2, a=0;

For the implementation principle inside the compiler, refer to "Compilation Principles". This is the problem of lexical analysis and grammatical analysis

It can only be used for variables and cannot be used for constants, which is a syntax provision, constants are used as read-only variables, and direct modification of constants will cause an error in the compilation stage, and variables modified by const are also read-only variables, and modification is prohibited. Here's how:

1. First, define a variable i and assign an initial value of 6.

2. Next, realize the self-addition of variable i, note that the ++ sign is after the variable.

3. Finally, the self-incrementing value of the output variable i is shown in the figure below.

4. Run the program, and you can see that the result is 7, indicating that the self-increment has been successfully realized.

5. Move the auto-increment sign ++ in the program to before variable i.

6. After running the program, you can see that the value after self-increment is still 7, which means that the self-increment is used alone, i++ and ++i, and the results of the two usages are the same.

>> can only be used for variables, not for variables.

Isn't it a question that it can only be used for variables and not constants?

If this is the case, this is a syntax provision, constants are read-only variables, and directly modifying constants will give an error during the compilation stage, and the variables modified by const are also read-only variables, and modifications are prohibited.

What does it mean to be able to use only for variables and not for variables?

First of all, both operations are autoincrement operations, and both can only be performed on variables, but there are slight differences between the two types of autoincrement.

x increments the value of x by 1 first, and then uses the value of x in the current expression.

x++ uses the value of x in the current expression, and then increments the value of x by 1.

For example: 1) int x=1; Output 1, x++ first uses the value of x in the current expression, and then increments the value of x by 1,; Output 2, which is incremented by 1 after the previous instruction x is self-incremented

2）int x=1;;output 2, +x increments the value of x by 1 first, and then uses the value of x in the current expression,; Output 2, which is incremented by 1 after the previous instruction x is self-incremented

x++ is actually divided into three steps: taking the value, calculating, and assigning the value for example: x=1, x++, in fact, the jvm defines a cache value y y=x; The value (only one time for the closed family) y=y+1;

Calculate x=y; Assignment and ++x, the steps are different, y=x; Valid value (only once) x=y; Assign y=y+1;Calculation: This is what the book says: x++ is to calculate first and then assign a value, and ++x is to assign a value first and then calculate.

The data types of the add++ auto-subtract - operation can be float and double.

In C, not all variables can use auto-increment and decrement operators; The following data types can be used: int, float, double, char, and long.

Auto-increment (++) adds 1 to the value of the variable, and is divided into prefix (e.g., ++i) and suffix (e.g., i++) prefix is to add 1 before use; The suffix is used first and then 1.

Self-subtracting (--subtracts the value of the variable by 1, and divides the prefix (e.g., --i) and suffix (e.g., i--) prefix formulas to subtract 1 before using them; The suffix is used first and then subtracted by 1.