C++_18_重载运算符

重载运算符

意义：使该类对象使用该运算符时 与 该运算符本意不同

就是 起别的作用了 范围 在 重载的那个类中起效

语法：

返回值类型 operator 运算符(形参列表)
{
    函数体;
}

举例：

注意 ：

​ 形参中 使用 & （引用）而不是 * （指针）

• 1 直接操作对象：通过引用，可以直接对传递进来的对象进行操作，就好像在操作原始对象本身，而不需要通过指针的间接访问。
• 2 引用在使用时不会涉及到指针的解引用操作，通常效率更高。
• 3 避免空指针问题

使用位置：

1 全局函数：
		形参列表中第一个参数为符号左边的变量，第二个参数为符号右边的变量
2 成员函数：
		调用该函数的对象就是符号左边的变量，形参中的参数就是符号右边的变量

分析：【首选成员函数 前提是 符号左侧 是自定义的 】

1、分析运算符的运算对象的个数
2、分析运算符左边的运算对象是 自定对象 还是其他
		左边：是其他 只能全局函数实现 （必须使用友元）
		左边：自定义对象
			可以用使用 全局函数 重载运算符（参数个数 和 运算符对象的个数一致）
			也可以使用 成员函数 重载运算符（参数可以少一个） （推荐）	

判断全局or成员：

看要要用重载后运算符使用地方的 左侧 运算对象是 自定义 对象 还是其他【系统提供的】

#  返回值类型 是  Data*   + 运算符 左边是 d01  右边是 d02 
#  此时 d01 d02 属于自定义 非系统所提供 所以可以成员函数 也可全局函数 
    Data  *d03 = d01 + d02;

优先使用成员函数 对其重载

示例1：

1 重载 +

方式一： 全局函数

全局函数对其重载 参数为2 个 【详细过程】

1 创建类与要实现的东西

开始解决报错 先选方式

2 开始 选择 那个方式

选择 全局函数或者成员函数 因为 运算符左侧 d01 是自定义的

3 开始重载

4 开始写 逻辑

也就是 你要重载目的实现的逻辑

目的 实现 d01 x + d02 x d01 y +d02 y

5 使用友元

6 为了打印d03 再多写一个函数 与重载+ 无关

7 开始运行：

代码：

#include <iostream>
using namespace std;
//当要重载的运算符左侧 运算对象  是自定义的【全局成员二选一】  还是系统提供的  【只能全局】
//   重载  +   方式一  全局函数 重载   当
class Data
{
 friend  Data* operator +(Data& d01, Data& d02);  //定义友元  
private:
 int x;
 int y;
public:
//无参构造
 Data()
 {
     x = 0;
     y = 0;
 }
 //都是为了给类的成员变量 x 和 y 进行初始化。
 //有参构造  写法1  用成员初始化列表的方式进行初始化
 Data(int x,int y):x(x),y(y)
 {
 }
 // 写法2  构造函数体内进行赋值初始化。
 // Data(int x,int y)
 // {
 //     this->x = x;
 //     this->y = y;
 // }


 void showInfo()  // 为了打印出d03  展示
 {
     cout <<x <<"\t"<< y << endl;
 }
};
//为了使用 Data类的私有成员 所以对其使用友元操作
// 重载语法：    
//  返回值类型 operator运算符(形参列表)

//使用 & （引用）而不是 * （指针）
//  1 直接操作对象：通过引用，可以直接对传递进来的对象进行操作，就好像在操作原始对象本身，而不需要通过指针的间接访问。
//  2 引用在使用时不会涉及到指针的解引用操作，通常效率更高。
//  3 避免空指针问题
Data* operator +(Data& d01, Data& d02)
{ 
     Data *xxz = new Data();  // 使用指针是为了 创建堆区的 新对象 来接收  避免直接创建 的是成员变量会随着函数结束而销毁
    //写逻辑
     xxz->x = d01.x + d02.x;  // 此处的d 是指针
     xxz->y = d01.y + d02.y;
     return xxz; 
}

int main(int argc, char const *argv[])
{
 Data d01(10,20);
 Data d02(10, 20);

 //   重载运算符  +  来使得 d01 x + d02 x d01 y +d02 y 
 //  返回值类型 是  Data*   + 左边是 d01  右边是 d02  
 //  d01  属于自定义的 所以可以全局可以成员
 Data  *d03 = d01 + d02;

 d03->showInfo();  //打印结果
 return 0;
}

方式二： 成员函数

1 首先 成员函数 在类中定义 并且 不涉及友元

2 成员函数设置为公共的 不然访问不到

3 成员函数对其重载 参数为1 个 并且参数 是符号右边的变量

// 返回值类型 operator+(形参)
{
  
}

#include <iostream>
using namespace std;
// 成员函数重载  +
class Data
{
private:
    int x;
    int y;
public:
    Data()
    {
        x = 0;
        y = 0;
    }
    Data(int x, int y) : x(x), y(y)
    {
    }
    //  使用成员函数重载运算符 +  首先没有 友元 
    //  调用该函数的对象就是符号左边的变量
    //   参数 就是符号右边的变量  此时的d  代表 d02
    Data *operator+(Data &d)
    {
        Data *xxz = new Data();
        xxz->x = this->x + d.x;   // this->x 代表就是 d01 的
        xxz->y = this->y + d.y;
        return xxz;
    }
};
int main(int argc, char const *argv[])
{
    Data d01(10, 20);
    Data d02(10, 20);
    // 想实现+重载计算d01 x + d02 x d01 y +d02 y
    // 因为符号未重载所以会报错
    Data *d03 = d01 + d02;
    return 0;
}