i++ 和 ++i 效率的分析以及自定义类型的自增/自减运算符重载实例

From: http://blog.csdn.net/leo115/article/details/8101541

我们通常在写for循环 的时候，要实现变量 i 的自增 1 ；往往会在i++ 和++i中随便挑一种写，对于i++和++i的理解，我们往往停留在返回的值的不同，其实i++与++i在实现效率上也有一定的不同(不考虑编译器优化的原因)。

++i的实现效率更高

解释如下：

i++ (在C++中) 在实现的时候，系统会产生一个 local object class INT的临时变量 用于存储原有的数据供返回值用；

[cpp] view plaincopy

1. ++i 的实现方式   
2. INT INT::operator++()  
3. {  
4.     *this = *this +1;  
5.     return *this;  
6. }  
7.   
8. i++的实现方式  
9.   
10. const INT INT::operator++(int)  
11. {  
12.     INT oldvalue = *this;  
13.     *this = *this+1;  
14.     return oldvalue;  
15. }  

所以从效率上来说 ++i 比 i++来的更有效率。

++i更高效

说明：

1、在不考虑编译器优化的条件下，前缀(++i)比后缀(i++)要少一步开辟临时变量的操作，所以前缀效率更高。

2、对于内置数据类型，由于编译器优化的原因，前缀和后缀的效率没什么差别。

例如：对于 int 型变量，编译器可以优化掉开辟临时变量这份多余的工作。

3、对于自定义的数据类型(类)，我们在使用 自增 运算符的时候，需要重载 ++ 运算符，在重载的时候，后缀要开辟一个临时变量，所以前缀的效率要比后缀的更高。

Stl中迭代器使用的是 前缀

自定义类型的 前缀和后缀 的重载的 实现方式如下：

说明：如果考虑对 前缀(++i --i) 重载形式为  Type operator++() ;

    后缀(i++ i--)的重载形式为:Type operator++(int); (这样定义是为了实现前缀与后缀的区分)

[cpp] view plaincopy

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class PlusOne  
6. {  
7. public:  
8.     int val;  
9. public:  
10.     PlusOne(int a):val(a){}  
11.     PlusOne operator++();  
12.     PlusOne operator++(int);  
13.     int getval() {return this->val;}  
14. };  
15. PlusOne PlusOne::operator++()  
16. {  
17.     this->val += 1;  
18.     cout<<this->val<<endl;  
19.     return *this;  
20. }  
21. PlusOne PlusOne::operator++(int)  
22. {  
23.     PlusOne tmp(*this);  
24.     this->val += 1;  
25.     cout<<this->val<<endl;  
26.     return tmp;  
27. }  
28.   
29.   
30. int main()  
31. {  
32.     PlusOne po(10);  
33.     PlusOne po1 = ++po;  
34.     PlusOne po2 = po++;  
35.     cout<<"po1.val:"<<po1.getval()<<endl;  
36.     cout<<"po2.val:"<<po2.getval()<<endl;  
37.     return 0;  
38. }  

运算结果如下：