为什么自增(increment)运算符的 前置(prefix) 比 后置(postfix) 效率高？

  先看一段代码：

 

view plain

1. #include <iostream>  
2. using namespace std;  
3. int main()  
4. {  
5.     int num1 = 1, num2 = 1;  
6.     int sum1, sum2;  
7.     sum1 = ++num1;  
8.     sum2 = num2++;  
9.     cout << "num1 = " << num1 << endl  
10.          << "num2 = " << num2 << endl  
11.          << "Sum1 = " << sum1 << endl  
12.          << "Sum2 = " << sum2 << endl;  
13.     return 0;  
14. }  

 输出结果为：

num1 = 2

num2 = 2

sum1 = 2

        sum2 = 1

 

 原理： 前置运算符，先将自身递增，然后返回自身；

   后置运算法，先创建自身的一个副本，而后自身递增，然后返回副本。

 

正如上例代码：

sum1 = ++num1; --> num1先自增本身，值变为2，再返回本身，sum1即被赋值为2；

          此时，num1 = 2, sum1 = 2。

        sum2 = num2++; -->num2先创建自身副本(假设为tmp)，tmp = num2，然后num2自增，

 值变为2，返回副本tmp，sum2即被赋值为1；

                                           此时，num2 = 2, sum2 = 1。

 

再来看一看运算符的重载，更加一目了然。

 

view plain

1. class A  
2. {  
3. public:  
4.     A& operator++(); //前置版本(prefix version)  
5.     A operator++(int);  //后置版本(postfix version)  
6. private:  
7.     int num;  
8. }  
9. inline A& A::  
10. operator++()  
11. {  
12.     num += 1;  
13.     return *this;  
14. }  
15. inline A A::  
16. operator++( int )  
17. {  
18.     A tmp = *this; //创建副本  
19.     num += 1;      //自身增加  
20.     return tmp;    //返回副本  
21. }