C++中自加(i++/++i)自减(i--/--i)运算符效率分析

╰+哭是因爲堅強的太久メ 2022-11-11 14:51 205阅读 0赞

**结论：优先使用 ++i 和 --i 以提高运行效率**

虽然大家都知道 **i++/i-- 是先使用再自加减**，而 **++i/--i 则是先自加减再使用**

首先回顾下：

# C++中自加自减运算符的重载 #

自增运算符`++`、自减运算符`--`都可以被重载，但是它们有前置、后置之分。  
  
以`++`为例，假设 obj 是一个 CDemo 类的对象，`++obj`和`obj++`本应该是不一样的，前者的返回值应该是 obj 被修改后的值，而后者的返回值应该是 obj 被修改前的值。如果如下重载`++`运算符：

CDemo & CDemo::operator ++ ()
    {
        //...
        return * this;
    }

那么不论`obj++`还是`++obj`，都等价于`obj.operator++()`无法体现出差别。  
  
为了解决这个问题，C++ 规定，在重载`++`或`--`时，**允许写一个增加了无用 int 类型形参的版本，编译器处理`++`或`--`前置的表达式时，调用参数个数正常的重载函数；处理后置表达式时，调用多出一个参数的重载函数。**来看下面的例子：

#include <iostream>
    #include <vector>
    using namespace std;
    
    class MyInt
    {
    public:
    	MyInt(int i = 0) { n = i; }
    	MyInt & operator++();//前置++，++i
    	MyInt operator++ (int);//后置++，i++
    
    	//友元函数形式的函数重载
    	friend MyInt & operator --(MyInt &);//前置--，--i
    	friend MyInt operator --(MyInt &, int);//后置--，i--
    
    	friend ostream & operator<<(ostream &out, MyInt in); //重载输出运算符
    	//或者重载int运算符
    	operator int() { 
    		cout << "重载了 << 运算符" << endl;
    		return n; 
    	}
    
    
    private:
    	int n;
    };
    
    
    MyInt & MyInt::operator++()
    {
    	n = n + 1;
    	return *this;
    }
    
    MyInt MyInt::operator++(int)
    {
    	//需要创建一个临时对象，保存之前的数据，然后再自加
    	MyInt temp(*this);
    	n = n + 1;
    	return temp;
    }
    
    MyInt & operator--(MyInt &i)
    {
    	i.n = i.n - 1;
    	return i;
    	
    }
    MyInt operator --(MyInt &i, int){
    	MyInt temp(i);//这里使用了默认拷贝构造函数
    	i.n = i.n - 1;
    	return temp;
    }
    ostream & operator<<(ostream &out, MyInt in)
    {
    	cout << "重载了 << 运算符" << endl;
    	out << in.n;
    	return out;
    }
    
    
    int main(void) {
    
    	MyInt i(666);
    	cout << "i = "<< i++ << endl;
    	cout << "i = " << ++i << endl;
    	cout << "i = " << i-- << endl;
    	cout << "i = " << --i << endl;
    
    	return 0;
    }
    /*
     *
     *
    i = 重载了 << 运算符
    666
    i = 重载了 << 运算符
    668
    i = 重载了 << 运算符
    668
    i = 重载了 << 运算符
    666*/

再回到自加自减的源码实现：

// 前置自加自减
    // ++i
    T& T::operator++(){       
        ++*this;             
        return *this;       
    }
    
    // --i
    T& T::operator--(){
        --*this;
        return *this;
    }

//后置自加自减
    T T::operator++(int){                   
        T old(*this);                           
        ++*this;                               
        return old;                             
    }                                       
    
    T T::operator--(int){
        T old(*this);
         --*this;
        return old;
    }

自增自减的后缀形式所多花费的开销:  
T old(\*this);  
这一句产生一个类型为T的临时对象 old, 并用原值\*this进行初始化.当函数return的时候,又再次创建一个临时对象,并用old的值进行初始,之后,局部变量old被销毁.并用临时创建的变量对赋值符左边的变量进行赋值(如果有的话).赋值后,临时变量再次被销毁.  
而前缀形式的自增自减呢?

首先函数内**没有创建临时变量**,故这方面的开销就节省了。其次,返回的是一个引用。故也**节省了这时候创建销毁临时对象的开销**.。

因此后缀式的自增自减，所多花费的开销是**两次临时变量的创建,以及两次临时变量的销毁**，如果自增自减的对象不是内建的数据类型，而一个类类型\[当然,你首先得重载自增自减操作符， 那么这个开销可能会比较大，因为变成了两次构造函数以及两次析构函数的调用。  
所以在调用代码的时候,要**优先使用前缀形式,除非确实需要后缀形式返回原值。**