【十一】运算符重载（下）

1、回顾上一节

上一节中，我们通过了两个全局友元函数进行了运算符重载，并且简单说明了如何进行类成员函数的运算符重载，这里首先将全局重载函数改写为成员重载函数！

示例：

#include <iostream>

using namespace std;

class Complex
{
private:
int a;
int b;
public:
Complex(int i = 0, int j = 0)
{
a = i;
b = j;
}
//成员函数操作符重载
Complex operator+ (const Complex& rb);
friend ostream& operator<< (ostream& out,const Complex& rc);
};

//“+”号运算符为双目运算符，所以重载参数有两个，且只能有两个，但是如果该重载函数为类的
//成员函数，那么就只能有一个显示的参数，因为会有一个隐藏的this指针参数
Complex Complex::operator+ (const Complex& rb)
{
Complex ret;
ret.a = this->a + rb.a;
ret.b = this->b + rb.b;

return ret;
}

//这里返回类型为ostream类对象的引用，是为了函数调用完成后，还能继续使用cout对象
//比如：cout << c3 << endl;  ==> (cout << c3) << endl;
//如果返回值不为ostream&，那么该调用会失败！
ostream& operator<< (ostream& out, const Complex& rc)
{
out << rc.a << " + " << rc.b << "i";

return out;
}

int main()
{
Complex c1(5, 2);
Complex c2(4, 9);
Complex c3 = c1 + c2;   //等价于：c1.operator+(c2);

cout << c3 << endl;     //等价于：operator<<(cout,c3);

cout << "Press any key to continue..." << endl;
cin.get();
return 0;
}

思考：

  什么时候使用全局函数重载操作符？什么时候使用成员函数重载操作符？

当无法修改左操作数的类的实现时，使用全局函数进行重载，用这种方法也能对原有的类进行功能扩展，即使我们没有源代码

C++规定，=, [], ()和->操作符只能通过成员函数进行重载

2、类的默认操作符重载

C++编译器会为每个类提供默认的赋值操作符，既是拷贝构造函数

默认的赋值操作符只是做简单的值复制

类中存在指针成员变量时就需要重载赋值操作符，因为一旦只进行简单的值复制，那么两个对象的的成员变量就同时指向了同一内存空间，这就会引发问题，比如，b对象是a对象的拷贝，如果a对象被析构，那么它申请的内存空间会被释放，而b对象此时正“使用”着该内存空间！

3、“++”和“–”运算符的重载

这两个操作符只有一个操作数

这两个操作符有前缀和有后缀的区分

思考：

那么，如何重载这两个操作符才能区分前置运算和后置运算？？

答案：

  可以通过占位参数来实现，因为操作符的重载本质上还是函数的重载，所以可以用参数的不同来区分两者，这里实现“++”运算符的重载来举例说明！

示例：

#include <iostream>

using namespace std;

class Complex
{
private:
int a;
int b;
public:
Complex(int i = 0, int j = 0)
{
a = i;
b = j;
}
//成员函数操作符重载
Complex operator+ (const Complex& rb);
friend ostream& operator<< (ostream& out,const Complex& rc);

Complex operator++ (int);  //obj++
Complex& operator++ ();   //++obj
};

//“+”号运算符为双目运算符，所以重载参数有两个，且只能有两个，但是如果该重载函数为类的
//成员函数，那么就只能有一个显示的参数，因为会有一个隐藏的this指针参数
Complex Complex::operator+ (const Complex& rb)
{
Complex ret;
ret.a = this->a + rb.a;
ret.b = this->b + rb.b;

return ret;
}

//这里返回类型为ostream类对象的引用，是为了函数调用完成后，还能继续使用cout对象
//比如：cout << c3 << endl;  ==> (cout << c3) << endl;
//如果返回值不为ostream&，那么该调用会失败！
ostream& operator<< (ostream& out, const Complex& rc)
{
out << rc.a << " + " << rc.b << "i";

return out;
}

//为了与内置版本保持一致，后置运算符应该返回对象的原值，返回一个值而非引用
//为了同时重载前置和后置运算符，后置版本接受一个额外的（不被使用）int类型的形参，当我们使用后置运算符时，编译器为这个形参提供一个值为0的实参
Complex Complex::operator++ (int) //obj++
{
cout << "obj++" << endl;
Complex temp = *this;

this->a++;
this->b++;

return temp;
}

//这里返回值使用引用是为了和内置版本保持一致
Complex& Complex::operator++ () //++obj
{
cout << "++obj" << endl;
this->a++;
this->b++;

return *this;
}

int main()
{
Complex c1(5, 2);
Complex c2(4, 9);

Complex temp = c2++; //等价于： temp = c2; c2.operator++(int);
temp = ++c2; //等价于： c2.operator++(); temp = c2;
(++c2)++;

Complex c3 = c1 + c2;   //等价于：c1.operator+(c2);

cout << c3 << endl;     //等价于：operator<<(cout,c3);

cout << "Press any key to continue..." << endl;
cin.get();
return 0;
}

4、不应该被重载的运算符

最好不要去重载”&&”、”||” 和 “,” 运算符，原因如下：

&&和||内置实现了短路规则

“,”号运算符的重载版本无法保证它原有的求值顺序

操作符重载是靠函数重载来完成的

操作数作为函数参数传递

C++的函数参数都会被求值，无法实现短路规则

5、不能被重载的运算符

‘::’ – 作用域运算符

‘.*’ – 成员指针运算符

‘.’ – 成员运算符

‘? :’ – 条件运算符

‘sizeof’ – sizeof运算符

TIPS:

  ”.*/->*” – 成员指针运算符的使用举例

#include <iostream>
using namespace std;

class CTEST
{

public:
double data;

public:

CTEST(double x)
{
data = x;
}

double fx(double x)
{
return data*data-x;
}
};

int main()
{
CTEST obj(3.14);        //定义一个类对象

CTEST *p = &obj;        //定义一个对象指针，并指向obj对象

double CTEST::*ip;      //定义一个类成员变量指针，注意和 double *ip; 区分

ip = &CTEST::data;      //让ip指针指向一个类成员变量，注意和 ip = &obj.data; 区分

cout << "obj.*ip = " << obj.*ip << endl;        //通过对象名使用成员变量指针访问
cout << "obj.data = " << obj.data << endl;      //普通的成员变量访问

cout << "p->*ip = " << p->*ip << endl;          //通过对象指针使用成员变量指针访问
cout << "p->data = " << p->data << endl;        //普通的成员变量访问

double (CTEST::*fp)(double);        //定义一个类成员函数指针，注意和 double (*fp)(double); 区分

fp = &CTEST::fx;                     //让fp指向类成员函数，这里得显示取地址，注意和 fp = &obj.fx; 区分

cout << "(obj.*fp)(0.5) = " << (obj.*fp)(0.5) << endl;
cout << "obj.fx(0.5) = " << obj.fx(0.5) << endl;

cout << "(p->*fp)(5.5) = "<< (p->*fp)(5.5) << endl;
cout << "(p->fx)(5.5) = " << (p->fx)(5.5) << endl;

return 0;
}

6、小结

操作符重载可以直接使用类的成员函数实现

=, [], ()和->操作符只能通过成员函数进行重载

++操作符通过一个int参数进行前置与后置的重载

C++中不要重载&&、|| 和 , 操作符

C++中不允许重载 ::、.*、. 、? :、sizeof运算符