C++ 自增、自減運算符的重載和性能分析

01 ++、--運算符重載函數的格式

自增運算符和自減運算符是有前置和後置之分的,如:函數

a++  // 後置自增運算符
++a  // 前置自增運算符

b--  // 後置自減運算符
--b  // 前置自減運算符

爲了區分所重載的是前置運算符仍是後置運算符,C++規定:性能

  • 前置運算符做爲一元運算符重載,重載爲成員函數的格式以下:
T & operator++(); // 前置自增運算符的重載函數,函數參數是空
T & operator--(); // 前置自減運算符的重載函數,函數參數是空
  • 後置運算符做爲二元運算符重載,多寫一個沒用的參數,重載爲成員函數的個數以下:
T  operator++(int); // 後置自增運算符的重載函數,多一個沒用的參數
T  operator--(int); // 後置自減運算符的重載函數,多一個沒用的參數

02 討論前置和後置運算符的返回值

前置和後置運算符重載函數以下:
前置運算符重載的成員函數 | 後置運算符重載的成員函數
---|---
T & operator++(); | T operator++(int);
T & operator--(); | T operator--(int);
注意到區別了嗎?那麼問題來了:this

  • 爲何前置運算符返回的是引用 &
  • 爲何後置運算符返回的是普通的對象(臨時對象)?

主要是由於爲了保持本來 C++ 前置和後置運算符的特性:code

  • 前置運算符的特性
int a = 0

// (++a) = 5; 能夠拆解成:
// a = a + 1; 
// a = 5;
(++a) = 5; // 前置++

a 先自增 +1 後, a 的值就爲 1 ,而後再參與 a=5 的運算,因此最後 a 的值是 5。對象

這說明 (++a) 返回的是自增後 a 變量, a 變量在後續運算過程當中,a 變量的值會被修改。因此前置運算符的重載函數的返回值必須是引用 &class

  • 後置運算符的特性

然後置運算符,是不能做爲左值的,也就是 (a++) = 5; 是不成立的,因此後置運算符的重載函數的返回值就是普通的對象。變量

03 ++、--運算符重載函數的編寫

int main()
{
    CDemo d(10);
    cout << d++ << ","; // 等價於 d.operator++(0);
    cout << d << ","; 
    
    cout << ++d << ","; // 等價於 d.operator++();
    cout << d << ",";
    
    cout << d-- << ","; // 等價於 d.operator--(0);
    cout << d << ",";
    
    cout << --d << ","; // 等價於 d.operator--();
    cout << d << endl;
    
    return 0;   
}

輸出結果:構造函數

10,11,12,12
12,11,10,10

假設要實現如上的 main 函數輸出的結果,該如何編寫呢?迭代器

首先咱們先定義好 CDemo 類,同時也把自增、自減運算符重載函數定義好。引用

class CDemo
{
public:
    CDemo(int i = 0):m_num(i) {} // 構造函數
    
    CDemo & operator++();    // 前置自增運算符重載
    CDemo  operator++(int);  // 後置自增運算符重載
    
    CDemo & operator--();    // 前置自減運算符重載
    CDemo operator--(int);   // 後置自減運算符重載

private:
    int m_num; // 成員變量
};

接着繼續實現前置自增、自減運算符重載函數:

// 前置++
CDemo & CDemo::operator++()
{
    ++m_num;
    return *this;
}

// 前置--
CDemo & CDemo::operator--()
{
    --m_num;
    return *this;
}

後置自增、自減運算符重載,就有點不一樣,例如後置++,是先參與運算,再進行自增,因此返回值是沒自增前的對象,具體實現以下:

// 後置++
CDemo CDemo::operator++(int)
{
    CDemo tmp(*this); // 記錄修改前的對象
    m_num--;
    return tmp;       // 返回修改前的對象
}

// 後置--
CDemo  CDemo::operator--(int)
{ 
    CDemo tmp(*this); // 記錄修改前的對象
    m_num++;
    return tmp;       // 返回修改前的對象
}

04 前置和後置運算符的性能比較

從上面的例子,咱們看到後置運算符的重載函數的執行步驟:

  1. 先要產生一個臨時對象來保存未自增或自減前的對象;
  2. 接着成員變量自增或自減;
  3. 最後返回修改前的對象;

而前置運算符的重載函數的執行步驟:

  1. 成員變量自增或自減;
  2. 返回對象引用;

可見,前置運算符的重載函數是比後置運算符的重載函數性能是更高的,開銷相對比較少。

固然對於普通變量類型,如int、double、long等,前置和後置是性能差距是不大的。重要是咱們在對於對象和迭代器使用自增或自減時,最好用前置的運算符的方式,這樣能夠減小開銷


相關文章
相關標籤/搜索