运算符重载概念：对已有的运算行程序进行定义，赋予其另一种功能，以适应不同的数据类型

加载运算符重载

作用：实现两个自定义数据类型相加的计算

总结:

1、对于内置的数据类型的表达式的的运算符是不可能改变的

2、不要滥用运算符重载

class Person{
Public:
    //成员函数重载+号
    Person operator+(Person &p){
        Person temp;
        temp.m_A = this->m_A+p.m_A;
        temp.m_B = this->m_B+p.m_B;
        return temp;
    }

    //全局函数重载+号
    Person operator+(Person &p1,Person &p2){
        Person temp;
        temp.m_A =p1.m_A+p2.m_A;
        temp.m_B =p1.m_B+p2.m_B;
        return temp;
    }

    //函数重载版本
    Person operator+(Person &p1,int num){
        Person temp;
        temp.m_A =p1.m_A+num;
        temp.m_B =p1.m_B+num;
        return temp;
    }

    int m_A;
    int m_B;
};

void test01(){
    Person p1;
    p1.m_A =10;
    p1.m_B =10;
    Person p2;
    p2.m_A =10;
    p2.m_B =10;

    //成员函数重载本质调用
    //Person p3 = p1.operator+(p2);
    //全局函数重载本质调用
    //Person p3=operator+(p1,p2);
    Person p3=p1+p2;
    //运算符重载，也可以发送函数重载
    Person p4 =p1+10;
    cout << "P3.m_A:"<<P3.m_A<<endl;
    cout << "P3.m_B:"<<P3.m_B<<endl;
    cout << "P4.m_A:"<<P4.m_A<<endl;
    cout << "P4.m_B:"<<P4.m_B<<endl;    
}

#include <iostream>
using namespace std;

class Person {
public:
    // 构造函数
    Person(int a = 0, int b = 0) : m_A(a), m_B(b) {}
    
    // 成员函数重载+号（第一种形式：Person + Person）
    Person operator+(const Person &p) const {
        return Person(this->m_A + p.m_A, this->m_B + p.m_B);
    }
    
    // 成员函数重载+号（第二种形式：Person + int）
    Person operator+(int num) const {
        return Person(this->m_A + num, this->m_B + num);
    }

    // 声明全局函数重载为友元（第三种形式：int + Person）
    friend Person operator+(int num, const Person &p);

    int m_A;
    int m_B;
};

// 全局函数重载+号（int + Person）
Person operator+(int num, const Person &p) {
    return Person(num + p.m_A, num + p.m_B);
}

void test01() {
    Person p1(10, 10);
    Person p2(10, 10);

    // 使用成员函数重载 Person + Person
    Person p3 = p1 + p2;
    
    // 使用成员函数重载 Person + int
    Person p4 = p1 + 10;
    
    // 使用全局函数重载 int + Person
    Person p5 = 10 + p1;
    
    cout << "p3.m_A: " << p3.m_A << endl;
    cout << "p3.m_B: " << p3.m_B << endl;
    cout << "p4.m_A: " << p4.m_A << endl;
    cout << "p4.m_B: " << p4.m_B << endl;
    cout << "p5.m_A: " << p5.m_A << endl;
    cout << "p5.m_B: " << p5.m_B << endl;
}

int main() {
    test01();
    return 0;
}

左移运算符重载

作用：可以输出自定义数据类型

重载左移运算符配合友元可以实现输出自定义数据类型

class Person{
    friend ostream& operator<<(ostream& out,Person& p);

public:
    //利用成员函数重载 左移运算符  p.operator<<(cout) 简化版本 p<<cout
    //不会利用成员函数重载<<运算符，因为无法实现cout在左侧
    // void operator<<(cout){
        
    // }

    //只能利用全局函数重载左移运算符
    //本质 operator<<(cout,p) 简化cout<<p;
    void operator<<(ostream &cout,Person &p){
        cout <<"m_A="<<p.m_A<<" m_B"<<p.m_B;        
    }

    ostream &operator<<(ostream &cout,Person &p){
        cout <<"m_A="<<p.m_A<<" m_B"<<p.m_B;  
        return cout;
    }

    Person(int a,int b){
        this->m_A = a;
        this->m_B = b;
    }

private:
    int m_A;
    int m_B;
};

void test01(){
    Person p;
    p.m_A = 10;
    p.m_B = 10;

    cout << p;
}

void test02(){
    Person p;
    p.m_A = 10;
    p.m_B = 10;

    cout << p <<endl;
}

递增运算符重载

作用：通过重载递增运算符，实现自己的整形数据

class MyInteger
{
    friend ostream& operator<<(ostream& cout,MyInteger myint);
public:
    MyInteger(){
        m_Num =0;
    }

    //重载前置++运算符,返回引用是为了一直对一个数据进行递增操作
    MyInteger& operator++(){
        m_Num++;
        return *this;
    }
    //重载后置++运算符，返回值,因为要拷贝一个记录当时结果
    //int代表占位参数，可以用于区分前置和后置递增
    MyInteger operator++(int){
        //先记录当时结果
        MyInteger temp =*this;
        //后递增
        m_Num++;
        //最后将记录结果做返回
        return temp;
    }

private:
    int m_Num;
}

//重载<<运算符
ostream& operator<<(ostream& cout,MyInteger myint){
    cout <<myint.m_Num;
    return cout;
}


void test01(){
    MyInteger myint:
    cout <<++myint <<endl;
}

void test02(){
    MyInteger myint:
    cout <<myint++ <<endl;
}

赋值运算符重载

C++编译器至少给一个类添加4个函数

1、默认构造函数（无参，函数体为空）

2、默认析构函数（无参，函数体为空）

3、默认拷贝构造函数，对属性进行值拷贝

4、赋值运算符 operator=，对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

class Person{
public:
    Person(int age){
        m_Age = new int(age);
    }

    ~Person(){
        if(m_Age!=NULL){
            delect m_Age;
            m_Age =NULL;
        }
    }

    //重载赋值运算符
    Person& operator=(Person &p){
        //编译器是提供浅拷贝
        //m_Age = p.m_Age;

        //应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
        if(m_Age!=NULL){
            delect m_Age;
            m_Age = NULL;
        }

        //深拷贝
        m_Age =new int(*p.m_Age);
        
        //返回对象本身
        return *this;
    }

    int *m_Age;
}


void test01(){
    Person p1(18);    
    Person p2(20);  
    Person p3(30);
    p3=p2=p1;

    cout <<"p1的年龄为："<<*p1.m_Age <<endl;
    cout <<"p2的年龄为："<<*p2.m_Age <<endl;
    cout <<"p3的年龄为："<<*p3.m_Age <<endl;
}

关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作

class Person{
public:
    Person(string name,int age){
        m_Name = name;
        m_Age = age;
    }

    //重载关系运算符
    bool operator==(Person &p){
        if(this->m_Name==p.m_Name&&this->m_Age==p.m_age){
            return true;
        }
        return false;
    }

    string m_Name;
    int m_Age;
}

void test01(){
    Person p1("Tom",18);
    Person p2("Tom",18);
    if(p1==p2){
        cout <<""<<endl;
    }
}

函数调用运算符重载

1、函数调用运算符（）也可以重载

2、由于重载后使用的方式非常像函数的调用，因此称为访函数

3、仿函数没有固定写法，非常灵活

class MyPrint{
public:
    void operator()(string test){
        cout <<test <<endl;
    }
}

//仿函数非常灵活，没有固定的写法
//加法类
class MyAdd{
public:
    int operator()(int num1,int num2){
        return num1+num2;
    }
};

void test01(){
    MyPrint myPrint;
    myPrint("Hello world");
}

void test02(){
    MyAdd myAdd;
    int ret=myAdd(10,10);
    cout <<ret <<endl;

    //匿名函数对象
    cout <<MyAdd()(100,100) <<endl;
}