（GeekBand）C++面向对象高级编程（上）第一周笔记（2）

第五节 操作符重载与临时对象

今天来分析一下操作符重载。

操作符的重载根据是否为类成员函数分为两种，在分析时会涉及到一个新的知识点：临时对象(temp object),语法是typename(),有效域为一行。

我们来看一下第一种操作符重载，在类中进行重载（+=）。

#include<iostream>
using namespace std;

class complex
{
private:
    double re,im;
    friend complex& _doapl(complex*,const complex&);//为重载时需要调用的函数开一个后门
public:
    complex(double r=0,double i=0):re(r),im(i)//构造函数，对re,im进行初始化
    {}
    complex& operator +=(const complex&);//重载函数
    double real() const{return re;}//get re
    double image() const{return im;}//get im
};

inline complex& //申请内联函数(与编译器相关)
complex::operator +=(const complex& r)//传入右值
{
    return _doapl(this,r);//调用_doapl(do assignment plus),this指向c2
}

inline complex&//返回*ths的引用
_doapl(complex* ths,const complex& r)//+=新算法（重载实现）
{
    ths->re+=r.re;
    ths->im+=r.im;
    return *ths;  //返回ths指针指向的变量，即c2
}

int main()
{
    complex c1(2,1);
    complex c2(5);
    c2+=c1;
    cout<<"("<<c2.real()<<","<<c2.image()<<")"<<endl;//打印结果
    return 0;
}

附一张运行结果：

下面来看第二种操作符重载，在类外进行重载（+，无this）。

根据不同类型的加法运算多次重载’+’运算符。

#include<iostream>
using namespace std;

class complex
{
private:
    double re,im;
public:
    complex(double r=0,double i=0):re(r),im(i)
    {}
    double real() const{return re;}//get re
    double image() const{return im;}//get im
};

inline complex//因为返回临时object所以用value而不是reference
operator + (const complex& x,const complex& y)
{
    return complex(x.real()+y.real(),x.image()+y.image());
}//对应c2=c1+c2

inline complex
operator + (const complex& x,double y)
{
    return complex(x.real()+y,x.image());
}//对应c2=c1+5

inline complex
operator + (double x ,const complex& y)
{
    return complex(x+y.real(),y.image());   
}//对应c2=7+c1

int main()
{
    complex c1(2,1);
    complex c2(5);
    c2=c1+c2;
    //c2=c1+5;
    //c2=7+c1;
    cout<<"("<<c2.real()<<","<<c2.image()<<")"<<endl;
    return 0;
}

附上一张运行结果：

在众多操作符中，有一种比较特殊，就是’<<’。在对’<<’操作符进行重载时，只能通过第二种方法，即在全局下重载，下面我们来看一下它的实现。

#include<iostream>
using namespace std;

class complex
{
private:
    double re,im;
public:
    complex(double r=0,double i=0):re(r),im(i)
    {}
    double real() const{return re;}
    double image() const{return im;}
};

inline ostream&
operator <<(ostream& os,const complex& r)
{
    return os<<'('<<r.real()<<','<<r.image()<<')';
}

int main()
{
    complex c1(2,1);
    cout<<c1<<endl;
    return 0;
}

这里简单的对操作符’<<’进行了重载，使其可是输入复数。那么请思考一下，既然在operator <<(ostream& os,const complex& r)函数我们已经更改了os,为什么还要return呢？

下面我们对代码稍作更改。

#include<iostream>
using namespace std;

class complex
{
private:
    double re,im;
public:
    complex(double r=0,double i=0):re(r),im(i)
    {}
    double real() const{return re;}
    double image() const{return im;}
};

void operator <<(ostream& os,const complex& r)//将返回类型更改为void
{
    os<<'('<<r.real()<<','<<r.image()<<')';//去掉了return
}

int main()
{
    complex c1(2,1);
    cout<<c1;//输出c1
    return 0;
}

运行结果：

既然结果相同，为什么不使用更易理解、使用没有返回值的方法呢？其实不然，这种方法有它的弊端，比如我们将主函数中的cout《c1换成cout《c1《endl，那么在编译时就会报错。原因是操作符’<<’将左值cout与右值c1传入重载函数后会返回void类型，这时表达式变成了void()》endl，操作符’<<’的左值应该是ostream类型而非void类型，所以会报错。为了适应我们一贯的书写习惯，建议使用返回ostream类型的方法。

Markdown使用还不太熟练，排版不够美观，见谅。
今天就到这吧，内容有点多，还有待消化。