自增运算深入

++a=8;++a可以当做左值使用,a++=8;错误 不可以当做左值使用

#include <stdio.h> 
void main()  /*主函数*/ 
{
 int a,b,c,d; 
 a=5;
 b=5; 
 c=(a++)+(a++)+(a++); 
 d=(++b)+(++b)+(++b); 
 printf("a=%d,b=%d,c=%d,d=%d\n",a,b,c,d); 

结果是什么?

而后Eric搜了一下后发现,类似的问题很多,也就是说对自增自减运算符感到迷惑是一个普遍存在的问题,基于此,Eric决定对自增自减运算符做个小小的解析,希望能给C语言爱好者们提供参考,解决对此问题的困惑。

自增自减运算符语法

自增运算符 ++ 使操作数的值加1,其操作数必须为可变左值(可简单地理解为变量)。对于自增就是加1这一点,Eric想大家都不会有什么疑问。

问题在于:++ 可以置于操作数前面,也可以放在后面,如:

++i;
  i++ ;
++i表示,i自增1后再参与其它运算;而i++ 则是i参与运算后,i的值再自增1。

自减运算符--与之类似,只不过是变加为减而已,故不重述。

实例剖析

下面我们通过一些实例来深入理解自增运算符的特性,自减运算符同理自悟

例一:

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

对此,Eric想大家都不会有什么困惑,结果就是 4,5;下面我们来做一点小改动:

int i=3;
  int j=4;
  int a = i++;
  int b = ++j;
  printf("%d, %d\n", a, b);

结果又是多少呢?这里就开始体现出++前置与后置的区别了,结果是3,5。结合此例,我们回头再来理解一下“++前置:i自增1后再参与其它运算;++后置:i参与运算后,i的值再自增1”。很明显,a = i++;由于是先执行赋值运算,再自增,所以结果是a=3,i=4;而b = ++j;
则因先自增,然后再赋值,所以b,j均为5。

其实基本道理就这么简单了,但在更复杂点的情况下又会如何呢,请看:

例二:

int i=3;
  int j=4;
  int a = i++ + i++;
  int b = ++j + ++j;
  printf("%d, %d\n", a, b);

问题又来了,i++ + i++是先自增一次,相加,再自增,然后赋值呢,还是先相加赋值然后自增两次呢。另外,++j又将如何表现呢?

结果是:6,12

这下明白了,原来 i++的理解应该是执行完整个表达式的其他操作后,然后才自增,所以例子中的a=3+3=6;而后i再自增2次,i=5;相反,++j是先自增然后再参加其它运算,所以b=6+6=12。

到此,是否就彻底明了了呢?然后回到引子中的问题:

例三:

int i=3;
  int j=4;
  int a = i++ + i++ + i++;
  int b = ++j + ++j + ++j;
  printf("%d, %d\n", a, b);

有人可能会说,这很简单,我全明白了:a=3+3+3=9,i=6,b=5+5+5=15,j=5。真的是这样吗?

结果却是:9,19

这下可好,又糊涂了。对于a = i++ + i++ + i++;我们已经没有疑问了,++后置就是执行完整个表达式的其他操作后,然后才自增,上例中也得到了验证,但 b = ++j + ++j + ++j;又该如何理解呢?

原理表达式中除了预算法本身的优先级外,还有一个结合性问题。在++j + ++j + ++j;中,因为存在两个同级的+运算,根据+运算符的左结合性,在编译时,其实是先处理前面的(++j + ++j)这部分,然后再将此结果再和++j相加。具体过程参见汇编代码:

int b = ++j + ++j + ++j;
0040B7DD   mov         ecx,dword ptr [ebp-8]
0040B7E0   add         ecx,1
0040B7E3   mov         dword ptr [ebp-8],ecx  // 第一个++j
0040B7E6   mov         edx,dword ptr [ebp-8]
0040B7E9   add         edx,1
0040B7EC   mov         dword ptr [ebp-8],edx  // 第二个++j
0040B7EF   mov         eax,dword ptr [ebp-8]
0040B7F2   add         eax,dword ptr [ebp-8]  // ++j + ++j 
0040B7F5   mov         ecx,dword ptr [ebp-8]
0040B7F8   add         ecx,1
0040B7FB   mov         dword ptr [ebp-8],ecx  // 第三个++j
0040B7FE   add         eax,dword ptr [ebp-8]  // ++j + ++j + ++j
0040B801   mov         dword ptr [ebp-10h],eax  // 赋值给b

另外我们看看a = i++ + i++ + i++;的汇编代码:

int a = i++ + i++ + i++;
0040B7B6   mov         eax,dword ptr [ebp-4]
0040B7B9   add         eax,dword ptr [ebp-4]    // i+i
0040B7BC   add         eax,dword ptr [ebp-4]   // i+i+i
0040B7BF   mov         dword ptr [ebp-0Ch],eax // 赋值给a
0040B7C2   mov         ecx,dword ptr [ebp-4]
0040B7C5   add         ecx,1
0040B7C8   mov         dword ptr [ebp-4],ecx  // 第一次i++
0040B7CB   mov         edx,dword ptr [ebp-4]
0040B7CE   add         edx,1
0040B7D1   mov         dword ptr [ebp-4],edx  // 第二次i++
0040B7D4   mov         eax,dword ptr [ebp-4]
0040B7D7   add         eax,1
0040B7DA   mov         dword ptr [ebp-4],eax  // 第三次i++

果然不出所料。到此,++运算符前置后置的问题应该彻底解决了。

为了验证一下上述结论,我们再看:

例四:

int i=1;
  int j=1;
  int a = i++ + i++ + i++ + i++ + i++ + i++ + i++; // 七个
  int b = ++j + ++j + ++j + ++j + ++j + ++j + ++j;
  printf("%d, %d\n", a, b);
  printf("%d, %d\n", i, j);

规则就是规则,咱的计算机可不是黑客帝国的母体,总是要遵循它的

a = 1+1+1+1+1+1+1 = 7,  i=8
b = 3+3+4+5+6+7+8 = 36,  j=8

一切OK,恭喜你还生活在21世纪的地球,不用担心matrix控制你的思维和生活

注:以上结果及解释出自VC编译器,但对于++这个问题是和编译器的解析有关的,不同厂家可能理解不一致,因手头没有其他开发环境,暂无法做全面分析,本文只是为了说明++,--这运算符的一些特性,尤其是前置后置的区别这个问题。类似的问题如果有困惑,最好是写程序做试验解决,请勿生搬硬套。谢谢!在实际的编程实践中,类似的问题除了要试验搞清外,Eric认为应该尽量避免引入环境相关的编程技巧。

自增运算深入

时间: 2024-08-30 07:44:45

自增运算深入的相关文章

编程题:自增运算与自减运算的运用

#include<stdio.h> void main() {int a1,a2,a3,a4,b1,b2,b3,b4; a1=a2=a3=a4=10; b1=(a1++)+(a1++)+(a1++); b2=(++a2)+(++a2)+(++a2); b3=(a3--)+(a3--)+(a3--); b4=(--a4)+(--a4)+(--a4); printf("a1=%d,a2=%d,b1=%d,b2=%d\n",a1,a2,b1,b2); printf("a

Swift自增和自增运算

1 自增和自增运算 2 3 和 C 语言一样,Swift 也提供了方便对变量本身加1或减1的自增(++)和自减(--)的运算符.其操作对象可以是整形和浮点型. ‌ 4 var i = 0 5 ++i // 现在 i = 1 6 每调用一次++i,i的值就会加1.实际上,++i是i = i + 1的简写,而--i是i = i - 1的简写. 7 8 ++和--既是前置又是后置运算.++i,i++,--i和i--都是有效的写法. 9 10 我们需要注意的是这些运算符修改了i后有一个返回值.如果你只想

指针取值(*)与自增(++)运算

++(*p) 先取指针指向的内容,然后给内容加1.加1操作当前生效. 等价于++*p (*p)++ 先取指针指向的内容,然后给内容加1,加1操作在该语句运行后生效 *(p++) p指针加1.加1操作在该语句运行后生效.然后取当前p指针指向的内容.等价于*p++ *(++p) p指针加1.加1操作当前生效,然后取当前p指针指向的内容.等价于*++p 对于不同类型的指针.自增自减时内存地址移动的长度与该类型所占的内存长度相等...

自增运算执行

X=X+1;    先读取等号右边的X的地址,计算X+1的值,再读取等号左边的X的地址,最后将等号右边的值传给等号左边. X+=1;    先读取等号右边的X的地址,计算X+1的值,最后将得到的值传给左边的X,因为X的地址在之前已经读出,故省去传值过程. X++:    先读取X的值,然后自增         

java自增运算

记得大学刚开始学C语言时,老师就说:自增有两种形式,分别是i++和++i,i++表示的是先赋值后加1,++i是先加1后赋值,这样理解了很多年也没出现问题,直到遇到如下代码,我才怀疑我的理解是不是错了: public class Client { public static void main(String[] args) { int count =0; for(int i=0;i<10;i++) { count=count++; } System.out.println("count=&q

指针的自增运算

*p++与*(p++)等价 ,相当于*(p+1)                       结果都为5.

C++中自定义类2种自增运算的代码实现和区别

本文首发于个人博客https://kezunlin.me/post/caef83a3/,欢迎阅读最新内容! cpp i++ vs ++i for user defined class Guide code #include <stdio.h> #include <stdlib.h> #include <string.h> #include <vector> #include <iostream> using namespace std; clas

java中自增自减运算与c中自增自减的区别

今天看到java面试宝典里面有一道题目是这样的: 答案是0,我开始也有疑问,后来看到后面说到java的中间缓存变量,后来到网上查了查,终于理解了,是什么意思了.请看下面的代码和解释: package com.wj.demo; public class Test1 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub int j=0; for(int i=

Java语法基础--运算

常量是一些不变的数据,我们用变量的方式把常量给记录下来,变量是内存中一个空间,空间中可以存储某些类型的数据,变量还有一个好处,就是可以给一些常量取名称,方便阅读: 取模运算 就是取余数.模2运算,非0即1,用于切换. -3%6结果是-3 . 3%-6结果是3 . 负数运算参考左边符号. 对于除号"/",它的整数除和小数除是有区别的:整数之间做除法时,只保留整数部分而舍弃小数部分. 例如:int x=3510;x=x/1000*1000;  x的结果是3. 自增运算 ++ int a=3