C 语言中的预自动增量和后自动递增问题

递增和递减运算符优先于大多数运算符，而先例优先于大多数运算符。

和 ||一旦可以确定整个表达式的值，左边的表达式就不再执行右边的表达式，而不是 & 和 |

所以，这是第一次：

z = 3 > 0 为真，z --, z = 2，判断正确。

x = 0， ++x， x = 1 < 5 为真。

y--，y = 4

第二次：z = 2 > 0 为真，z --, z = 1，判断正确。

x = 1， ++x， x = 2 < 5 为真。

y--，y = 3

第三次：z = 1 > 0 为真，z--,z = 0，判断正确。

x = 2， ++x， x = 3 < 5 为真。

y--，y = 2

第四：z = 0 > 0 为 false，z--,z = -1，向右跳过。

x = 3，被跳过，并且值保持不变。

y = 2，条件为 false，未执行，值不变。

所以结果是：

x = 3, y = 2, z = -1

循环条件的自增自减义： z-->0 这个判刑在执行后减去 1，+x<5 在执行刑期前 x 加 1 后判定为小于 5

第一次 3>0 &&&1<5 y==4

第二次>0 &&2<5 y==3

第三次 1>0 &&3<5 y==2

第四个 0>0 是 “false”，在 & 之后不再执行，但 z- 仍然要执行，所以结果是 3， 2， -1。 我不知道这个答案是否像你所知道的那样不同。

注意：Z--在循环中，先取z判断>0，然后z-1=2，++x等于1（++x是先加1）。

输出为 1,4,2

多写几个自增自减的测试题，然后在电脑上调试一下，应该就能搞清楚了。

z--：之后执行。

x：首先执行。

即第一个循环：z=3>0&&x=1<5

然后 z--;

while（z-->0&&+x<5） 请注意，当 z--不大于 0 时，不执行 ++x < 5。

计算：从右到左，输出到 Buffer。

1. 缓冲区是一个堆栈。

2.第一步：将以下“i--”8处理到缓冲区中，i=7。 缓冲区：8<-（指针）。

第 2 步：将“i++”7 处理到缓冲区中，i=8。 缓冲区：

78< - 第 3 步：处理“--i”。 8 进入缓冲区，i=7

缓冲区：878 第 4 步：处理“++i” 首先自增量 1，然后 8 进入缓冲区，i=8

缓冲区：8878

3.输出缓冲区数据（堆栈规则）：8878

此外，自递增、自递减，也可能与编译器有关。

计算：从右到左，输出到 Buffer。

1. 缓冲区是一个堆栈。

2.第一步：将以下“i--”8处理到缓冲区中，i=7。 缓冲区：8<-（指针）。

第 2 步：将“i++”7 处理到缓冲区中，i=8。

缓冲区：7 8< - 第 3 步：处理“--i”。

8 进入缓冲区，i=7缓冲区：8 7 8 步骤 IV：

处理 “++i” 先增量 1，然后处理 8 进入缓冲区，i=8缓冲区：8878

3.输出缓冲区数据（堆栈规则）：8 8 7 8 此外，自增、自减，也可能与编译器有关。

首先，你的这种用法应该是非法的，或者至少是非常不可取的。 由于算术运算符（如 + 和 - ）不指定计算操作数的顺序，因此可以首先在不同的编译器上找到操作数或正确的操作数。 因此，建议不要使用这种不确定的公式。

这里你首先找到左边的操作数，也就是先找到++n表达式的值，因为它是前缀自动增量，所以表达式（左操作数）的值是6，n也变为6然后找到右运算值，即表达式 n++; ，因为它是后缀自动增量，所以表达式的值是 6，所以第二个操作数的值是 6，所以结果是 36之后，n 变为 7

scanf 输入 6[x=6]， x>5 为 true，后继无条件执行 x++[x=7]，由于满足上述条件，printf 输出 7

scanf 输入 4[x=4]， x>5 不为 true，则无条件执行 x++[x=5]，因为前面的条件不满足，printf 输出 5，执行 x--[x=4]。

因此，当输入 6 时，我们得到输出 7; 当您输入 4 时，您将获得输出 5

输入 6 时，满足 if 语句，x+1，输出 7，程序结束;

输入 4 时，不满足 if 语句，x+1，输出 5，x-1，程序结束。

++前面表示变量先自递增，然后运行方程，所以m=++i，先执行++i，i变为9，然后赋值给m;

最后，它意味着先计算方程，然后变量自增，所以先执行 n=j++，n 赋值给 10，然后 j 自增到 11

++，意思是先自加，再计算。

++之后，表示先计算，再自加。

所以，m=++i; 首先进行自加法，即 i=i+1; 我=9;

再手术，m=i; 米=9;

n=j++;先操作，即 n=j; n=10;

然后自加，即j=j+1; J=11;

结果是：i=9，j=11，m=9，n=10

有一个简单的记忆方法，++在前面，即先自我增加，i在最后，即自我增加后给值; 反之，i先来，即先给出i的值，最后给出++的值，即给出值后自增。

m=++i;i先自增，自增后为9，再给mn=j++9; 首先将 j 的值 10 给 n，然后自行增加它，j 变成 11，这样你就得到了结果。

应避免使用自递增或自递减表达式作为函数参数，因为不同的编译系统在计算时没有统一的方法。 例如;

i=1;c=fun(i,++i);

从左到右计算时，c=fun（1,2）;

如果从右到左计算，则为 c=fun（2,2）;

这种问题不需要深入研究，但是在调用函数之前应该确定参数的值，然后再将函数作为参数调用。

第一段**：

我是先增加 i 的值，然后再使用它。

p=f(i,++i);就是先执行++i，再进行函数调用。 因为执行++i后，i的值变成了3，所以等价于p=f（3,3）;

你可以在函数 f 中打印出 a 和 b 的值，你会发现 a 和 b 都是 3

第二段**：

i++ 是先用 i 的值，再把 i 的值加 1

所以它等价于先执行 p=f（2,2）;

执行后，将 i 的值更改为 3答案应该是 0

我怀疑你老师的课件写错了，所以我建议你问他。

主要的自加自减法问题，你的记忆方面，给出一个方法。

x++ 表达式的值从左到右看 x 的位置，此时 x 在 ++ 的左边，没有 ++，所以 x++ 表达式的值是 x 的值。

反之，++x，x在++的右边，表达式的值是x+1的值，但无论哪种方式，只要执行完成，x的值就是+1

x--, x。

因此，当 6： if（6>5） 和输出 74： if（4>5） 不满足时，执行 x--,但此时 x 已经执行了 ++，所以 x 是 5 之前 --

x--表达式的值为 5

我以前不明白这个问题，但现在我会了。 不明白真的很烦人。 首先，i=8，m=++i，前面是+1，然后取值，然后是m=9，此时i是+1之后运算的结果，i=，n=j++

最后，是先取值，再取+1; 那么n先的值是j+1之后的值，j=11

在表达式中，++和标题一样，在变量前面，它是自增和减法，然后取变量值。 变量之后，先取变量的值，然后自增自减。

例如：j=i++; 这意味着 i 的值首先分配给 j，然后 i 是自递增的。 这也是以下**的含义。 您可以使用此想法进行跟进。

i++ 和 ++i 在 C 语言中都是自动增量，但它们以不同的顺序自增量。 ++i 表示 I 递增 1 然后参与其他操作，而 i++ 表示 I 参与操作，i 的值递增 1。

第四行被赋值 j， j=3，然后 i+1=4

第 5 行 printf 也被计算出来，认为执行了 i++ 操作 j=3，输出为 i=4，然后计算出 i=i+1=5

在第 6 行中，i+1=5+1=6，然后 j=6

在第 7 行中，输出 i+1=6+1=7，输出 i=7J 不变或 6，第 6 行与第 1 行相同。

i- 1 一次输出 6 个，j 也是 6，然后 i 减去 1 次 = 5;

最后两行道理也是留给房东去思考的，其实printf最好不要把计算步骤放进去，很容易忽略。

如果您不明白，请询问。

这真的是关于编译器的。

以下是 VS2019 运行的结果：

下面是 clion 运行的结果：

Clion 的警告是 x++ 是没用的，检查后，它说 x++ 应该放在赋值操作之后，所以它应该放在赋值操作之后。

x = x +(i++)

x++;所以正确的结果应该是 6,3

结果取决于编译器，不同的编译器会有不同的结果，6,3

它应该是 b 7 3

x++ 是 4，i++ 是 3

4+3 是 7，应选择 B

算术水平高于其他运算符

我们很乐意为您解答！

答案是5,3。

因为要看具体的编译软件，不同的便衣软件都有自己的规则，用户往往被蒙在鼓里。 即使用户自己了解某个变音符号软件的操作规则，编写的程序也缺乏可移植性和可读性。 如果你在其他编译软件上编译它，你会得到不同的结果，所以说像这样模棱两可的语句的最好方法是远离它，把它分成两个或多个语句。

(3*3+3*3)=18;

证明。

我的意思是我先自我加法，然后参与运算,--我先减法再参与运算;

i++ 表示 i 先参与运算，然后加自身,--i 表示 i 先参与运算，然后减去自身;

在整个方程（i++*i+i--*i）中，i在参与运算之前加了一次，然后又减去自身（++i,--i），所以i的值没有变化，它仍然是3，运算后，i的值再加后减去（++i,--i），所以i的值仍然没有变化， 并且仍然等于 3

所以计算结果是 3

操作完成后，i=3;

记住一句口头禅：先增加，然后给予。

第一个和最后一个值是指操作员位置。

增加和充实是指首先要采取什么行动。

示例：i++;

赋值后，算子在后面，所以先进行赋值操作，进行自加。