关于前缀自增运算符与后缀自增运算符的区别，以及利弊

旧城等待， 2022-08-19 13:09 162阅读 0赞

C语言的自增++，自减--运算符对于初学者来说一直都是个难题，甚至很多老手也会产生困惑，最近我在网上看到一个问题：  
\#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  
  
  
注：以上结果及解释出自VC编译器，但对于＋＋这个问题是和编译器的解析有关的，不同厂家可能理解不一致，因手头没有其他开发环境，暂无法做全面分析，本文只是为了说明＋＋，－－这运算符的一些特性，尤其是前置后置的区别这个问题。类似的问题如果有困惑，最好是写程序做试验解决，请勿生搬硬套。谢谢！在实际的编程实践中，类似的问题除了要试验搞清外，Eric认为应该尽量避免引入环境相关的编程技巧。

--------------------

总结一句话：vc环境中：  
\++i++i先使i的值自增两次再赋值！

i++i++先赋值再使i的值自增两次！

很久以前（八十年代），没有办法区分++和--操作符的前缀与后缀调用。这个问题遭到程序员的报怨，于是C++语言得到了扩展，允许重载 increment 和 decrement操作符的两种形式。然而有一个句法上的问题，重载函数间的区别决定于它们的参数类型上的差异，但是不论是increment或decrement的前缀还是后缀都只有一个参数。为了解决这个语言问题，C++规定后缀形式有一个int类型参数，当函数被调用时，编译器传递一个0做为int参数的值给该函数。

increment的前缀形式表示“增加然后取回”，后缀形式表示“取回然后增加”。

Sample code:

**\[cpp\]** [view plain][] [copy][view plain]

1.  \#include "stdafx.h" 
2.  \#include "assert.h" 
3.  **class** A 
4.  \{ 
5.  **public** : 
6.   A( **int** i) 
7.   :m\_i(i) 
8.   \{ 
9.   \} 
10. // ++i 
11.  A& operator++() 
12.  \{ 
13.  \++m\_i; 
14. **return** \* **this** ; 
15.  \} 
16. // i++ 
17. **const** A operator++( **int** ) 
18.  \{ 
19.  A tmp = \* **this** ; 
20.  \++(\* **this** ); // Implemented by prefix increment 
21. **return** A(tmp); 
22.  \} 
23. **int** m\_i; 
24. \}; 
25. **int** \_tmain( **int** argc, \_TCHAR\* argv\[\]) 
26. \{ 
27. **int** i = 0; 
28. **int** i1 = i++; // i1 = 0; i = 1; 
29. **int** i2 = ++i; // i2 = 2; i = 1; 
30.  A a(0); 
31.  A a1 = a++; // i1 = 0; i = 1; 
32.  A a2 = ++a; // i2 = 2; i = 1; 
33. 
34. //a++++; //avoid 
35. //++++a; //support 
36.  assert(i1 == a1.m\_i); 
37.  assert(i2 == a2.m\_i); 
38. **return** 0; 
39. \}

说明

1. 类中的++操作符号重载之后必须保证其语意与全局++相同。

2.为了区分前后，用++()表示前自增，用++(int)后自增。

3.因为按照前自增的标准定义,应该支持"++++a"的语法,而且两次前自增都应该是对a对象的自身操作,如果返回A类型,那第二次前自增调用的是临时对象的前自增操作。  
4.后自增应该返回"const Complex".这可以防止形如"a++++"的用法。

5.一般通过前自增操作来实现后自增操作符函数。

参考  
C++ articles:Guru of the Week \#4 -- Class Mechantics

More Effective C

[view plain]: http://blog.csdn.net/ccbird88/article/details/6014518#