操作符重载（二）
目录
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;
}
前置、后置重载的区别
- 对于基础类型的变量，前置++和后置++的效率基本相同，没有什么区别
- 对于类类型的对象，前置++的效率高于后置++，因为后置++重载会调用构造与析构函数
- 在工程中尽量使用前置++重载以提高程序效率
