17、C++运算符的重载

C++运算符的重载

重载运算符类似重载函数，同一个操作符不同类型的参数，有不同的操作。

一般用两种函数实现：类的成员函数、友元函数，全局函数也可以实现，不过

一般的全局函数不能访问类的私有成员，如果将其声明为公有的，就破坏

了数据的封装性。

一、重载运算符的规则：

1、只可重载C++自带的已有的运算符，不允许定义新的运算符。

2、部分运算符不可以进行重载。

下面是不可重载的运算符：

. 成员访问运算符

. * 成员指针访问运算符

:: 作用域运算符

sizeof 长度运算符

?: 条件运算符

3、重载不能改变运算符的操作对象的个数。单目运算符只能重载为单目的。

4、重载不能改变运算符的优先级。

5、重载不能改变运算符原的的结合特性。

6、运算符重载函数的参数至少有一个是类对象 或类对象的引用。(成员函数的第一个

参数是调用该操作符的对象)

7、运算符重载函数可以是普通的函数，也可以是类的成员函数，还可以是类的友元函数。

8、一般而言，用于类对象的运算符必须重载，但是赋值运算符=除外，编译器会自动添

加一个，但是只适用于值类型，如果有指针成员，就需要自定义。

二、友元函数重载运算符

基本语法1：定义与声明全在类内部

friend 返回类型 operator 运算符(参数列表)

{

}

基本语法2：声明在类内部，而定义在类外部

声明：

friend 返回类型 operator 运算符(参数列表);

定义：

函数类型 operator 运算符(参数列表)

{

函数体

}

友元函数重载的操作符是几目的，就有几个参数。

双目运算符：

隐式调用 ： aa@bb

显示调用：operator @(aa,bb)

注：aa bb 是两个参与运算的参数(两个数据类型的实例)，@是操作符。

单目运算符：

隐式调用：@aa  或  aa@

显示调用：operator @(aa)

三、成员函数重载运算符

第一个参数只能是调用的当前对象。如果第一个参数不是当前对象，而是别的，

那么就不能使用成员函数。

基本语法1：定义与声明都在类的内部

返回类型 operator 运算符(形参表)

｛

｝

基本语法2：声明在类内部，定义在类外部

声明：

返回类型 operator 运算符(形参表)；

定义：

返回类型 类名：：operator 运算符(形参表)

{

函数体

}

操作符如果是

双目操作符：那么只有一个参数，因为第一个参数是调用该操作符

的当前对象。

隐式调用： aa@bb

显示调用：aa.operator @(bb)

单目操作符：没有参数

隐式调用：aa@  或 @aa

显示调用：aa.operator @(bb)

四、两种函数的比较

1、成员运算符的参数个数始终比实际个数少一个，因为第一个总是当前调用的对象。

2、如果第一个参数不是该类对象实例，那么就只能使用友元函数。

对于单目运算符，建议选择成员函数

对于运算符 = 、( ) 、[ ] 、-> 只能作为成员函数

对于运算符 +=、 -=、*=、/=、&=、!=、~=、%=、<<=、>>=、

等建议重载为成员函数。

对于其它运算符，建议重载为友元函数

测试用例：

#include <iostream>

using namespace std;

class CComplex{

    private:

        double real;

        double imag;

    public:

    CComplex(double r,double i);

    ~CComplex()

    {

    }

    double getReal()

    {

        return this->real;

    }

    double getImag()

    {

        return this->imag;

    }

    //成员函数重载运算符：+  -

    CComplex & operator +(const CComplex &com);

    CComplex & operator -(const CComplex &com);

    //友元函数重载运算符: *

   friend  CComplex & operator *(const CComplex &com1,const CComplex &com2);

};

CComplex::CComplex(double r,double i):real(r),imag(i)

{

}

CComplex & CComplex::operator +(const CComplex &com)

{

    //返回引用只能返回出了 函数仍然内存仍然不被释放的对象的引用

    CComplex *rcom=new CComplex(0,0);//申请一段新内存，并将一个指针指向。直到不用时手动删除。

    //返回引用时不能返回局部对象或者形参的引用，因为一出了函数。这段内存就被释放了。

    rcom->real=this->real+com.real;

    rcom->imag=this->imag+com.imag;

    return *rcom;//接收的时候也必须用引用，不然就只是普通的值的复制，而不是引用，如果有指针成员就会出错。

}

CComplex & CComplex::operator -(const CComplex &com)

{

     CComplex *rcom=new CComplex(0,0);

    //返回引用时不能返回局部对象，因为一出了函数。这段内存就被释放了。但是可以返回形参为引用的，

    //因为这个引用的是实参，不会随着出了函数而消失。

    rcom->real=this->real-com.real;

    rcom->imag=this->imag-com.imag;

    return *rcom;

}

CComplex & operator *(const CComplex &com1,const CComplex &com2)

{

    CComplex *com=new CComplex(0,0);

    com->real=com1.real*com2.real-com1.imag*com2.imag;

    com->imag=com1.real*com2.imag+com1.imag*com2.real;

    return  *com;

}

int main()

{

    CComplex com1(1,2);

    CComplex com2(20,30);

    CComplex &com3=com1+com2;//如果这里不用引用(也不是指针)接收,那么就需要调用复制构造函数。

    cout<<"com1.real="<<com1.getReal()<<endl;

    cout<<"com1.imag="<<com1.getImag()<<endl;

    cout<<"com2.real="<<com2.getReal()<<endl;

    cout<<"com2.imag="<<com2.getImag()<<endl;

    cout<<"com3.real="<<com3.getReal()<<endl;

    cout<<"com3.imag="<<com3.getImag()<<endl;

    //delete (&com3);记得有new 的,就一定要delete

    CComplex &com4=com2-com1;

    cout<<"com4.real="<<com4.getReal()<<endl;

    cout<<"com4.imag="<<com4.getImag()<<endl;

    CComplex &com5=com1*com2;

    cout<<"com5.real="<<com5.getReal()<<endl;

    cout<<"com5.imag="<<com5.getImag()<<endl;

    delete &com3;

    delete &com4;//这里的&是取址符

    delete &com5;

    return 0;

}

程序输出结果：

com1.real=1

com1.imag=2

com2.real=20

com2.imag=30

com3.real=21

com3.imag=32

com4.real=19

com4.imag=28

com5.real=-40

com5.imag=70

Process returned 0 (0x0)   execution time : 2.028 s

Press any key to continue.