[TOC] 1. 數組操作符重載 數組操作符重載 通過重載數組操作符，可以使類的對象支持數組的下標訪問 數組操作符只能重載為類的成員函數 重載函數能且僅能使用一個參數，也就是數組下標 可以定義不同參數的多個重載函數 在重載數組操作符時，要記得數組操作符的原生語義——數組訪問和指針運算。 cpp / ...
目錄
1. 數組操作符重載
數組操作符重載
通過重載數組操作符，可以使類的對象支持數組的下標訪問
- 數組操作符只能重載為類的成員函數
- 重載函數能且僅能使用一個參數，也就是數組下標
- 可以定義不同參數的多個重載函數
在重載數組操作符時，要記得數組操作符的原生語義——數組訪問和指針運算。
a[n] <--> *(a + n) <--> *(n + a) <--> n[a]
#include <iostream>
#include <string>
using namespace std;
class Test
{
int a[3];
public:
int &operator [] (int i)
{
return a[i];
}
int &operator [] (const string &s)
{
if( s == "1st" )
{
return a[0];
}
else if( s == "2nd" )
{
return a[1];
}
else if( s == "3rd" )
{
return a[2];
}
return a[0];
}
};
int main()
{
Test t;
for (int i = 0; i < 3; i++)
{
t[i] = i;
}
for (int i = 0; i < 3; i++)
{
cout << t[i] << endl;
}
cout << endl;
cout << t["3rd"] << endl;
cout << t["2nd"] << endl;
cout << t["1st"] << endl;
return 0;
}
數組類IntArray改進
IntArray.h
class IntArray
{
public:
int &operator [] (int index); //Add
IntArray &self(); //Add
};IntArray.cpp
int &IntArray::operator [] (int index)
{
return m_pointer[index];
}
IntArray &IntArray::self()
{
return *this;
}2. 函數操作符重載（函數對象）
- 函數操作符只能通過類的成員函數重載
- 可以定義不同參數的多個重載函數
- 函數操作符重載的本質是使用具體的類對象取代函數，也就是函數對象，函數對象具備函數調用的行為
- 函數對象用於在工程中取代函數指針
/*
* 本示例代碼實現以下需求：
* - 編寫一個函數，可以獲得斐波那契數列每項的值
* - 每調用一次返回一個值
* - 函數可根據需要重覆使用
*/
#include <iostream>
#include <string>
using namespace std;
class Fib
{
int a0;
int a1;
public:
Fib()
{
a0 = 0;
a1 = 1;
}
Fib(int n)
{
a0 = 0;
a1 = 1;
for(int i = 2; i <= n; i++)
{
int t = a1;
a1 = a0 + a1;
a0 = t;
}
}
int operator () ()
{
int ret = a1;
a1 = a0 + a1;
a0 = ret;
return ret;
}
};
int main()
{
Fib fib;
for(int i = 0; i < 10; i++)
{
cout << fib() << endl;
}
cout << endl;
for(int i = 0; i < 5; i++)
{
cout << fib() << endl;
}
cout << endl;
Fib fib2(10);
for(int i = 0; i < 5; i++)
{
cout << fib2() << endl;
}
return 0;
}
3. 指針操作符重載與智能指針
指針操作符重載
指針操作符指的是->和*
- 指針操作符只能通過類的成員函數重載
- 重載函數不能使用參數，也就是說，只能定義一個重載函數
智能指針
- 利用指針操作符重載，可以實現智能指針
- 智能指針只能用來指向堆空間中的對象或者變數！！！
- 智能指針在生命周期結束時會自動釋放堆空間
- 智能指針的意義在於減少開發人員的記憶體管理工作，最大程度上避免記憶體問題。
/*
* 實現智能指針類Pointer，要求如下:
* - 一片堆空間最多只能由一個指針標識
* - 禁止指針運算和指針比較
*/
#include <iostream>
#include <string>
using namespace std;
class Test
{
int i;
public:
Test(int i)
{
cout << "Test(int i)" << endl;
this->i = i;
}
int value()
{
return i;
}
~Test()
{
cout << "~Test()" << endl;
}
};
class Pointer
{
private:
Test *mp;
public:
Pointer(Test *p = NULL)
{
mp = p;
}
Pointer(const Pointer &obj)
{
mp = obj.mp;
const_cast<Pointer &>(obj).mp = NULL;
}
Pointer &operator = (const Pointer &obj)
{
if (this != &obj)
{
delete mp;
mp = obj.mp;
const_cast<Pointer &>(obj).mp = NULL;
}
return *this;
}
Test *operator -> ()
{
return mp;
}
Test &operator * ()
{
return *mp;
}
bool isNull()
{
return (mp == NULL);
}
~Pointer()
{
delete mp;
}
};
int main()
{
Pointer p1 = new Test(0);
Pointer p2 = p1;
cout << p1.isNull() << endl;
cout << p2->value() << endl;
Pointer p3;
p3 = p2;
cout << p2.isNull() << endl;
cout << p3->value() << endl;
return 0;
}
4. 前置、後置操作符重載
重載實現
前置、後置操作符指的是++和--，我們以++為例進行講解，--和++是一樣的
- 全局函數和成員函數均可進行重載
- 重載前置++操作符不需要參數
- 重載後置++操作符需要一個int類型的占位參數
#include <iostream>
#include <string>
using namespace std;
class Test
{
int mValue;
public:
Test(int i)
{
mValue = i;
}
int value()
{
return mValue;
}
Test &operator ++ ()
{
++mValue;
return *this;
}
Test operator ++ (int)
{
Test ret(mValue);
mValue++;
return ret;
}
};
int main()
{
Test t1(0);
Test t2(0);
Test t = t1++;
cout << t.value() << endl;
cout << t1.value() << endl;
t = ++t2;
cout << t.value() << endl;
cout << t2.value() << endl;
return 0;
}
前置、後置重載的區別
- 對於基礎類型的變數，前置++和後置++的效率基本相同，沒有什麼區別
- 對於類類型的對象，前置++的效率高於後置++，因為後置++重載會調用構造與析構函數
- 在工程中儘量使用前置++重載以提高程式效率
