c语言自加自减三道题

int  x , y,z;

x = 0;

y = z = -1;

x += -z ---y;

printf(“x=%d\n”,x)

x = 2

为什么？

x  + = -z - - -y 相当于

x = x + ((-z)--)-y; 这里-z—是先用-z然后再(-z)- -运算

这里需要注意的是操作符结合的顺序是自左至右，而运算顺序是自右至左！

也就是 –z - - -y 表示的是 （（-z）--）-y 而不是 (-z)-(--y)

---

#include <stdio.h>

int main()

{

struct st

{

int n;

struct st *next;

};

struct st a[3],*p1,*p2,*p3,*p4;

a[0].n = 5;

a[0].next = &a[1];

a[1].n = 7;

a[1].next = &a[2];

a[2].n = 9;

a[2].next = '\0';

p1 = p2 = p3 =p4 = &a[0];

printf("p1++->n = %d\n",p1++->n);

printf("p1->n = %d\n",p1->n);

//printf("p2->n++ = %d\n",p2->n++);

//printf("p2->n = %d",p2->n);

//printf("(*p3).n++ = %d\n",(*p3).n++);

//printf("(*p3).n = %d\n",(*p3).n);

//printf("++p4->n = %d\n",++p4->n);

}

第一组

printf("p1++->n = %d\n",p1++->n); //p1++>n = a[0].n = 5

printf("p1->n = %d\n",p1->n); //此时在上一句执行完之后 p1++->n中的p1执行了p1++操作，p1是指针，它每增加一个单位就是增加一个指针位，所以p1++就使p1指向了a[0]下一个变量的地址，即a[1]的地址，此时p1->n就是a[1].n的值，所以此时 p1->n = a[1].n = 7

第二组

printf("p2->n++ = %d\n",p2->n++); //p2->n++ = 5 注意 p2也是指向a[0]的，所以p2->n = a[0].n，然后执行完只一句之后，就执行了p2->n++ 执行加加操作， 此时其实操作的a[0].n的值自加1，那么 p2->n++之后，a[0].n的值由原来的5就变成了6

printf("p2->n = %d",p2->n); //p2->n = 6, 这里等于6 是因为上面加加了。

第三组

printf("(*p3).n++ = %d\n",(*p3).n++); //(*p3).n++ = 5 这里的 *p3 就相当于a[0],所以(*p3).n = a[0].n 也就等于5 了

printf("(*p3).n = %d\n",(*p3).n); //这里在上面的(*p3).n++之后 a[0].n 变成了6.

第四组

printf("++p4->n = %d\n",++p4->n); //这里的 ++p4->n = 6 为什么？ 明显 p4->n相当于a[0].n 因为这里的 –> 的优先级高于 ++ , -- 等操作符，所以要先结合 ->操作，所以++p4->n 就相当于++(p4->n)

printf("a[0].n = %d\n",a[0].n); 这个语句在上面的p4测试之后加测的一句，证明a[0].n = 6 也就是证明 ++(p4->n) 是分析正确的。

上面这个问题其实就是操作符优先级的问题，具体可以参考c语言操作符优先级问题

---

#include <stdio.h>

int main()

{

int x = 2,y,z;

int i = 2;

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

printf(“I = %d”,i);

y = (++x)+(x++)+(++x);

z = x--+--x+x--;

printf("x=%d,y=%d,z=%d",x,y,z);

return(0);

}

printf("++i=%d,i++=%d,++i=%d\n",++i,i++,++i);  // 5, 3, 5

printf(“I = %d\n”,i); // 6

输出结果是

++I = 5,i++ =3, ++I = 5  这表明 先是是第一个 ++I 和和 第三个++I 自加之后，然后此时i是5，再printf()时就是 5,3,5,然后printf()之后， i又自加了，所以后面那个I = 6

printf("x=%d,y=%d,z=%d",x,y,z); // x = 2, y = 12,z = 12;

首先明白：

++在前边是,先自加1再使用

++在后边是先使用数值,再自加1

y=(++x)+(x++)+(++x);

i++是先使用i本身的值，再把i+1；

++i是先把i+1，再使用i的值运算。

y=(++x)+(x++)+(++x)  ：先处理括号内的运算

++x，x的值+1变为3

x++，暂时不变

++x，x的值+1变为4

现在相当于y=x+x+x=4+4+4=12；x再加1=5；

z=(x--)+(--x)+(x--)：先处理括号内的运算

x--，暂时不变

--x，x变为4

x--，暂时不变

z=x+x+x=4+4+4=12

然后x自减两次变为2。

 y=++x;y+=x++;y+=++x;z=x--;z+=--x;z+=x--;这样才是正确的使用

补充：

别算了，在TC里面结果是2,12,12,；在VC里面是2,10,12,

补充：

　自加自减在复杂表达式中的处理方法
3. 1　前加分解法
设i1, i2, ?, in , s 均为变量, op 为运算符, 且有表达式s = (+ + i1)op (+ + i2)op ?op (+ + in) (3—1)
若op 为逻辑与运算符(&&) , 且存在im (1 ≤m ≤n) ,使得im + 1 = 0, 但ik + 1 ≠ 0 (1 ≤ k ≤m ) , 则表达
式(3—1) 可分解为
i1 = i1 + 1; i2 = i2 + 1; ...; im = im + 1;
s = 0
否则, 表达式(3—1) 可分解为
i1 = i1 + 1; i2 = i2 + 1; ...; in = in + 1;
s = 1
若op 为逻辑或运算符(‖) , 且存在im (1 ≤m ≤ n) ,使得im + 1 ≠ 0, 但ik + 1 = 0 (1 ≤ k ≤m ) , 则表达
式(3—1) 可分解为
i1 = i1 + 1; i2 = i2 + 1; ...; im = im + 1;
s = 1
否则, 表达式(3—1) 可分解为
i1 = i1 + 1; i2 = i2 + 1; ...; in = in + 1;
s = 0
若op 双目算术运算符, 则表达式(3—1) 可分解为
i1 = i1 + 1; i2 = i2 + 1; ...; in = in + 1;
s = i1 op i2 op ... op in;
3. 2　后加分解法
设i1, i2, ..., in , s 均为变量, op 为运算符, 且有表达式s = ( i1 + + )op ( i2 + + )op ...op ( in + + ) (3—2)
若op 为逻辑与运算符(&&) , 且存在im (1 ≤m ≤n) ,使得im = 0, 但ik ≠ 0 (1 ≤ k ≤m ) , 则表达式(3—2)
可分解为
s = 0
i1 = i1 + 1; i2 = i2 + 1; ...; im = im + 1;
否则, 表达式(3—2) 可分解为
s = 1
i1 = i1 + 1; i2 = i2 + 1; ...; in = in + 1;
若op 为逻辑或运算符(‖) , 且存在im (1 ≤m ≤ n) ,使得im ≠ 0, 但ik = 0 (1 ≤ k ≤m ) , 则表达式(3—2)
可分解为
s = 1
i1 = i1 + 1; i2 = i2 + 1; ...; im = im + 1;
否则, 表达式(3—2) 可分解为
s = 0
i1 = i1 + 1; i2 = i2 + 1; ...; in = in + 1;
若op 双目算术运算符, 则表达式(3—2) 可分解为
s = i1 op i2 op ... op in;
i1 = i1 + 1; i2 = i2 + 1; ...; in = in + 1;
3. 3　前减分解法
设i1, i2, ..., in , s 均为变量, op 为运算符, 且有表达式
s = (- - i1)op (- - i2)op ...op (- - in) (3—3)
若op 为逻辑与运算符(&&) , 且存在im (1 ≤m ≤n) ,使得im - 1 = 0, 但ik - 1 ≠ 0 (1 ≤ k ≤m ) , 则表达
式(3—3) 可分解为
i1 = i1 - 1; i2 = i2 - 1; ...; im = im - 1;
s = 0
否则, 表达式(3—3) 可分解为
i1 = i1 - 1; i2 = i2 - 1; ...; in = in - 1;
s = 1
若op 为逻辑或运算符(‖) , 且存在im (1 ≤m ≤ n) ,使得im - 1 ≠ 0, 但ik - 1 = 0 (1 ≤ k ≤m ) , 则表达
式(3—3) 可分解为
i1 = i1 + - 1; i2 = i2 - 1; ...; im = im - 1;
s = 1
否则, 表达式(3—3) 可分解为
i1 = i1 - 1; i2 = i2 - 1; ...; in = in - 1;
s = 0
若op 双目算术运算符, 则表达式(3—3) 可分解为
i1 = i1 - 1; i2 = i2 - 1; ...; in = in - 1;
s = i1 op i2 op ...op in;
3. 4　后减分解法
设i1, i2, ..., in , s 均为变量, op 为运算符, 且有表达式
s = ( i1 - - )op ( i2 - - )op ...op ( in - - ) (3—4)
若op 为逻辑与运算符(&&) , 且存在im (1 ≤m ≤n) ,使得im = = 0, 但ik ≠ 0 (1 ≤ k ≤ m ) , 则表达式(3—4) 可分解为
s = 0
i1 = i1 - 1; i2 = i2 - 1; ...; im = im - 1;
否则, 表达式(3—4) 可分解为
s = 1
i1 = i1 - 1; i2 = i2 - 1; ...; in = in - 1;
若op 为逻辑或运算符(‖) , 且存在im (1 ≤m ≤ n) ,使得im ≠ 0, 但ik = 0 (1 ≤ k ≤m ) , 则表达式(3—4)可分解为
s = 1
i1 = i1 - 1; i2 = i2 - 1; ...; im = im - 1;
否则, 表达式(3—4) 可分解为
s = 0
i1 = i1 - 1; i2 = i2 - 1; ...; in = in - 1;
若op 双目算术运算符, 则表达式(3—4) 可分解为
s = i1op i2op ...op in;
i1 = i1 - 1; i2 = i2 - 1; ...; in = in - 1;
若op 为其他C 运算符, 则根据其优先级、结合方向和前(后) 加(减) 依次进行运算即可。一个表达式可能是上述几种表达式的复合, 但只要按上述分解方法, 不管表达式中有多少个自加自减运算, 无论含自加自减运算的表达式多么复杂,即使初学者也会运用自如。
4　举例
例1　若有说明
in t k = 3, s;
则语句
s = (+ + k ) + (+ + k) + (k - - ) + (k + + ) ;
可分解为
k = k + 1; k = k + 1;
s = k + k + k + k;
k = k - 1; k = k + 1;
由此可知, k 的值为5, s 的值为20。
例2　复合语句
{s = 3
p 1 + + ; 3
p 1 = 3
p 2 - - ; 3
p 2 = s; }
可分解为
{s = 3
p 1; p 1 = + + ; 3
p 1 = 3
p 2; p 222; 3
p 2 = s; }

补充：

y=(++x)+(x++)+(++x);/*x=x+1;x=x+1;y=x+x+x;x=x+1;*/z=(x--)+(--x)+(x--);/*x=x-1;z=x+x+x;x=x-1;x=x-1*/说明：++x的优先级最高，其次到（），最后才是x++。

---

总结

分两种情况：

一种是在一个表达式中出现多个自增自减及加减混合运算，此时怎么算？如下：

x = 2;

y = ++x+x--+(++x)+x+++(--x) 等于多少？最后x等于多少？

面对這样的式子运算方向：先计算所有的前置自增及自减运算,此时计算出来的x值就是式子中每个x的值，此时去掉所有的自增自减符号计算y的值，最后计算x的后置自增自减值，具体计算过程如下：

还有一种就是：

I = 2;

printf(“%d,%d,%d”,++I,i++,++i); 这输出的结果到底是什么？ 答案是 5,3,5

在这里是先计算最右边的那个 ++I 那么此时的I 就变成了3,然后计算中间那个i++，当碰到后置运算时，编译器会申请一个零时寄存器把当前的i为3的值保存起来，当前记为寄存器1，然后紧接着进行i++计算，此时I的值为4，然后计算最左边那个++i，此时i加出来的值为5， 此时i值被保存为5，然后入栈，在入栈中保持两个++i的寄存器的值都是重新通过mov指令将当前的i值mov到这些寄存器中然后入栈的，所以此时第一个++i和最后一个++i入栈的值都为5， 而中间那个i++入栈的值则是从零时寄存器1直接入栈，所以此时的i++位置的值为3，而printf(“%d,,,,”,++I,i++,i++)中这后面的参数表示++I,i++,++i所代表的地址中的值，然printf时，会去这些地址中取值，当时之前入栈的时候，往这些地址中写入值的时候是写入的5,3,5，所以这里取出来时也会是5,3,5，所以打印出来的就是,5,3,5.

c语言在函数参数的入栈方向上是自右向左的，如下printf()是先计算++j，然后再计算j++，然后再计算i++,等…….

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

00F237BD  mov         eax,dword ptr [j]

00F237C0  add         eax,1

00F237C3  mov         dword ptr [j],eax

00F237C6  mov         ecx,dword ptr [j]

00F237C9  mov         dword ptr [ebp-0E8h],ecx

00F237CF  mov         edx,dword ptr [j]

00F237D2  add         edx,1

00F237D5  mov         dword ptr [j],edx

00F237D8  mov         eax,dword ptr [i]

00F237DB  mov         dword ptr [ebp-0ECh],eax

00F237E1  mov         ecx,dword ptr [i]

00F237E4  add         ecx,1

00F237E7  mov         dword ptr [i],ecx

00F237EA  mov         edx,dword ptr [i]

00F237ED  mov         dword ptr [ebp-0F0h],edx

00F237F3  mov         eax,dword ptr [i]

00F237F6  add         eax,1

00F237F9  mov         dword ptr [i],eax

00F237FC  mov         ecx,dword ptr [i]

00F237FF  mov         dword ptr [ebp-0F4h],ecx

00F23805  mov         edx,dword ptr [i]

00F23808  add         edx,1

00F2380B  mov         dword ptr [i],edx

00F2380E  mov         esi,esp

00F23810  mov         eax,dword ptr [j]

00F23813  push        eax

00F23814  mov         ecx,dword ptr [ebp-0E8h]

00F2381A  push        ecx

00F2381B  mov         edx,dword ptr [ebp-0ECh]

00F23821  push        edx

00F23822  mov         eax,dword ptr [ebp-0F0h]

00F23828  push        eax

00F23829  mov         ecx,dword ptr [ebp-0F4h]

00F2382F  push        ecx

00F23830  push        offset string "i++=%d,i++=%d,i++=%d,j++=%d,++j="... (0F25A60h)

00F23835  call        dword ptr [__imp__printf (0F282B4h)]

00F2383B  add         esp,18h

00F2383E  cmp         esi,esp

00F23840  call        @ILT+305(__RTC_CheckEsp) (0F21136h)

总结

---

当计算式为一个表达式，表达式中有前置/后置自增自减/加减混合运算时：

Step1:从表达式左边到右边用括号括出前置/后置自增自减运算符

Step2:从表达式左边到右边依次计算所有前置运算符，计算某个变量x的最终值为当前表达式中所有这个变量x的当前值

Step3:从表达式左边至右边进行加减运算符计算，计算所得值为当前表达式的值

Step4:从表达式左边到右边分别计算各个变量的后置运算符，计算所得变量值，为各变量最终值

例如：

x = 1 y =2;

z = ++x+x--+(--y)+(++x)+y+++(--x)+(++y);

下面分步解析：

Step1:用括号自左至右括出自增自减前置后置运算符，下面分步解析：

1. z = (++x)+x--+(--y)+(++x)+y+++(--x)….

2. z = (++x)+(x--)+(--y)+(++x)+y+++(--x)….

3. z = (++x)+ (x--)+(--y)+(++x)+y+++(--x)….

……

Step1最终形式：

z = (++x)+(x--)+(--y)+ (++x)+ (y++)+(--x)+ (++y);

Step2:自表达式左边至右边计算所有的前置运算：

所有的前置运算如：

z = (++x)+(x--)+(--y)+ (++x)+ (y++)+(--x)+ (++y);

注意自左至右计算，x初始值为1，先算++x 得到x=2,然后算中间的++x 此时得到x = 3,然后再算最后的—x 得到x =2,至此变量x的所有前置运算结束，此时z表达式中出现变量x的地方，它们的值都是2.,此时z表达式可“简化”为：

z = 2+2+(--y)+ 2+ (y++)+2+ (++y);

计算y的所有前置运算：y初始值为2，自左至右计算，先算—y得到y=1,再算++y得到y=2,此时z表达式中所有y的值均表示为2，此时z表达式可进一步“简化“为：

z = 2+2+2+ 2+ 2+2+ 2;

Step3:从表达式左边到右边计算加减运算来计算z表达式的值，显然z = 2*7 =14

Step4: 从表达式左边到右边分别计算各个变量的后置运算符，计算所得变量值，为各变量最终值

所有前置运算之后，x=2,y=2,此时为”简化”的z表达式中后置运算如：

z = (++x)+(x--)+(--y)+ (++x)+ (y++)+(--x)+ (++y);

对x进行后置计算 得x = 1,对y进行后置运算得y=3

从上面可以看出表达式计算一直都是从左边计算到右边的！

下面是函数参数的运算：这个是从右边到左边的！

I = j = 2;

printf("++i=%d ,--i=%d,i++=%d,i++=%d, ++i=%d ,j++=%d,++j=%d\n",++i,--i,i++,i++,++i,j++,++j);

这里先计算 ++j,然后计算j++,然后依次计算++i,i++,i++,--I,++i

这里需要注意的是，在前置运算时，对变量进行的前置运算会是全局的，就是说按照上面的计算对i的前置计算顺序是 先++I,然后—I,最后++I,這样计算之后，在最后计算++i之后得到的i值将是这”++I,--I,++i”三个位置的值，就是这三个位置的值是一样的，而碰到后置运算时，会先申请一个临时地址或寄存器把当前变量值存储起来，然后再计算其后置运算。

下面详细分析其计算过程

printf("++i=%d ,--i=%d,i++=%d,i++=%d, ++i=%d , --j=%d ，j++=%d,++j=%d\n",++i,--i,i++,i++,++i,--j,j++,++j);

c语言函数参数入栈顺序是自右向左，所以这里的计算顺序是自右向左，所以从++j开始计算。

首先I = j  = 2 初始化都为2

第一步计算++j 是前置计算，计算值直接复制给j， 所以第一步的结果是 j = 3

第二步计算j++,这里遇到后置计算，计算前先甚至一个临时寄存器假设为Reg1,保留当前j的值，然后再进行后置计算，所以这里又分两步：第一步申请临时寄存器Reg1保存j=3的值，然后j后置加加,结果是 Reg1 = 3 ,j = 4

第三步计算--j,这里是前置计算，所以直接计算 –j 得到j = 3

注：这里j的三个表达式计算完了，这里第三步计算出来的j的值将”赋值”给第一步的计算值，也就是输出结果时第一步和第三步是一样的， 当然这里刚好第一步自身计算的值也和第三步是一样的。第二步输出的值就是那个Reg1的值，所以

printf(“……--j=%d,j++=%d,++j=%d”,…..,--j,j++,++j)实际输出是

printf(“……--j=%d,j++=%d,++j=%d”,…..,j=3,Reg1=3,j=3)

下面接着分析：

第四步计算++i， 前置运算直接算，得到 i = 3

第五步计算i++,后置计算，要先申请临时寄存器保存当前值，然后再计算，申请Reg2 = i =3,然后i++ 得i=4,

第六步计算i++,还是后置计算，还是先申请临时寄存器保存当前i=4的值，然后再进行后置计算，那么就是Reg3 = i = 4, 然后i++ ,得到i = 5

第七步计算，--i 前置计算，直接计算得到i = 4

第八步计算++i，前置计算，直接计算得到 i = 5

之前说了，所有的前置计算具有全局性，就是变量i有多个前置运算表达式，那么计算完所有的变量i的前置运算后，所有前置运算表达式中的i值就是这个最终计算的值，第八步计算的i= 5， 而i的前置运算分布在第四步，第七步，第八步，那么这三步目前的表达式中i都是i = 5,这就是所谓的”全局”性，而后置运算表达式的i则是其临时寄存器中的值，第五步中i++的变量i的值现在是其临时寄存器Reg2的值，也就是i = 3, 第六步中的i值也就是Reg3中的值，也就是i = 4

，所以最终输出结果是：

gcc运行结果：

vs2010运行结果：

运行结果正如我们所示。