第30课 操作符重载的概念

1、操作符重载

    1.1、 C++中的重载能够扩展操作符的功能

    1.2、 操作符的重载以函数的方式进行，本质上是用 特殊形式的函数 扩展操作符的功能

    1.3、 通过 operator 关键字可以定义特殊函数，operator的本质是通过函数来重载操作符

    1.4、 语法： Type operator Sign (const Type& p1, const Type& p2); //Sign 如+、-、*等

/****************      操作符重载初探     *************/

#include <stdio.h>

class Complex

{

private:

    int a;

    int b;

    

public:

    Complex(int a = 0, int b = 0)

    {

        this->a = a;

        this->b = b;

    }

    

    int getA()

    {

        return a;

    }

    int getB()

    {

        return b;

    }

     。const对象的引用，只能调用const成员函数，不能修改对象中的变量。

    //方式一： 通过全局普通的函数实现复数相加 ，，为了在外部访问类中私有成员，用友元声明。

    friend Complex Add(const Complex& p1, const Complex& p2);//这个函数是这个类的友元函数

    

    //方式二：通过全局函数重载“+”操作符实现复数相加,

    friend Complex operator + (const Complex& p1, const Complex& p2);   

};

//全局普通函数

Complex Add(const Complex& p1, const Complex& p2)

{

// 返回临时对象，声明周期只有这一行，对象销毁，自动调用构造函数。

    Complex ret;    //不能返回局部对象的引用，因为对象出栈时被销毁了。

    ret.a = p1.a + p2.a;    //因为是友元函数，所以可以直接访问。

    ret.b = p1.b + p2.b;

    

    return ret;

}

//全局重载操作符 +   ,,重载的实质就是为了扩展函数功能

Complex operator + (const Complex& p1, const Complex& p2)

{

    Complex ret;

    ret.a = p1.a + p2.a; //友元函数，直接使用那个类私有成员

    ret.b = p1.b + p2.b;

    

    return ret;

}

int main()

{

    Complex c1(1, 2);   //使用对象来初始化，调用构造函数。

    Complex c2(3, 4);

    //方式一的调用

    //Complex c3 = Add(c1, c2);   //函数实现复数的计算，缺点:无法写成c1 + c2的形式。

    //方式二的调用

    //Complex c3 = operator+(c1, c2); //把“opertor”当成函数名一样的调用。

    

    Complex c3 = c1 + c2;   //更加直观，但是本质上还是调用"operator+"这个函数。

    

    printf("c3.a = %d, c3.b = %d\n", c3.getA(), c3.getB());

    

    return 0;

}

2、可将操作符重载函数定义为类的成员函数

    2.1、 比全局操作符重载函数 少一个参数 （ 左操作数 ）

    2.2、 不需要依赖友元就可以完成操作符重载

    2.3、 编译器 优先 在 成员函数 中寻找操作符重载函数

/****************      成员函数重载操作符     *************/

#include <stdio.h>

class Complex

{

private:

    int a;

    int b;

    

public:

    Complex(int a = 0, int b = 0)

    {

        this->a = a;//普通函数是具有this参数的，静态函数没有。初始化每个对象的成员变量。

        this->b = b;

    }

    

    int getA()

    {

        return a;

    }

    int getB()

    {

        return b;

    }

    

    //方式一： 通过全局普通的函数实现复数相加 ，，为了在外部访问类中私有成员，用友元声明。

    friend Complex Add(const Complex& p1, const Complex& p2);//这个函数是这个类的友元函数

    

    //方式二：通过全局函数重载“+”操作符实现复数相加,

    friend Complex operator + (const Complex& p1, const Complex& p2);   

    //方式三：通过成员函数实现 “+” 操作符的重载

    Complex operator+(const Complex& p) //参数少了一个左操作数！因为普通成员函数有this指针关键字。

    {

        Complex ret;    //将返回值复制给临时对象。

        ret.a = this->a + p.a;      //this ->a 是对象里面的数据。

        ret.b = this->b + p.b;

        

        return ret;

    }

};

//全局普通函数

Complex Add(const Complex& p1, const Complex& p2)

{

    Complex ret;

    ret.a = p1.a + p2.a;    //因为是友元函数，所以可以直接访问

    ret.b = p1.b + p2.b;

    

    return ret;

}

//全局重载操作符 +   ,,重载的实质就是为了扩展函数功能

Complex operator + (const Complex& p1, const Complex& p2)

{

    Complex ret;

    ret.a = p1.a + p2.a;

    ret.b = p1.b + p2.b;

    

    return ret;

}

int main()

{

    Complex c1(1, 2);   //使用对象来初始化，调用构造函数。

    Complex c2(3, 4);

    //方式一的调用

    //Complex c3 = Add(c1, c2);   //函数实现复数的计算，缺点:无法写成c1 + c2的形式。

    //方式二的调用

    //Complex c3 = operator+(c1, c2); //把“opertor”当成函数名一样的调用。

    

    //Complex c3 = c1 + c2;   //更加直观，但是本质上还是调用"operator+"这个函数。

    

    //方式三的调用

    Complex c3 = c1.operator+(c2);  //把“operator + ”当成函数名一样的调用，c1对象的函数。

    //Complex c3 = c1 + c2;   //优先选择成员函数，而不是全局的opertor+ 函数。

    

    printf("c3.a = %d, c3.b = %d\n", c3.getA(), c3.getB());

    

    return 0;

}

3、小结

    （1）操作符重载是C++的强大特性之一，其本质是通过函数扩展操作符的功能

    （2）operator关键字是实现操作符重载的关键

    （3）操作符重载遵循相同的函数重载规则

    （4）全局函数和成员函数都可以实现对操作符的重载，但编译器优先选择通过成员函数实现的操作符重载函数