C++运算符重载案例

1.加号运算符重载

#include <iostream>
using namespace std;
#include <string>

// 加号运算符重载
// 实现两个自定义数据类型的相加运算
// 1.通过成员函数  2.通过全局函数

class Person{
    public:

    // 1.通过成员函数重载+号
    // 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;
    // }

    int m_A;
    int m_B;
};

// 2.通过全局函数重载+号
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;
}


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

    Person p2;
    p2.m_A = 10;
    p2.m_B = 10;

    // 1.成员函数重载+号 本质调用
    // Person p3 = p1.operator+(p2);

    // 2.全局函数重载+号 本质调用
    // Person p3 = operator+(p1, p2);

    // 上面两种调用都可以简化为以下形式 即实现了加号运算符重载函数operator+()后，便可使用这种形式相加
    Person p3 = p1 + p2; 

    cout << "p3.m_A = " << p3.m_A << endl;
    cout << "p3.m_B = " << p3.m_B << endl;
}

void test02(){
    // 测试运算符重载的函数重载是否可行
    Person p1;
    p1.m_A = 10;
    p1.m_B = 10;

    Person p4 = p1 + 100; 

    cout << "p4.m_A = " << p4.m_A << endl;
    cout << "p4.m_B = " << p4.m_B << endl;
}


int main(){
    test01();
    test02();
}

2.左移运算符重载

#include <iostream>
using namespace std;
#include <string>

// 作用：可以输出自定义数据类型
// 1.通过成员函数(不行)  2.(只能)通过全局函数


class Person{

    friend ostream& operator<<(ostream &cout, Person &p);

   public:
   Person(int a, int b){
       m_A = a;
       m_B = b;
   }

    // 1.利用成员函数来重载左移运算符 p.operator<<(cout) 简化版本 p << cout
    //   因此一般不会利用成员函数重载<<运算符，因为无法实现cout在左侧
    // void operator<<(cout){
    //     cout << "" << endl;
    // }

    private:
    int m_A;
    int m_B;

};

// 只能通过全局函数重载左移运算符
ostream& operator<<(ostream &cout, Person &p){ 
    // 该函数 的本质是 operator<<(cout,p) 简化形式为 cout << p
    // cout 的数据类型是标准的输出流对象,并且全局只有一个,因此只能以引用的方式传过来，而不能新创建一个对象
    cout << "m_A = " << p.m_A << endl;
    cout << "m_B = " << p.m_B << endl;
    return cout; // 从而可以链式编程 可以无限追加输出
}

void test01(){
    Person p(10,10);

    cout << p << endl;

}

int main(){
    test01();
}

3.递增运算符重载

#include <iostream>
using namespace std;
#include <string>

// 作用：通过重载递增运算符，实现自己的整型数据
// 1.前置递增  // 2.后置递增

// 首先需要重载左移运算符
// 然后实现前置递增和后置递增的++运算符



class MyInteger{

    friend ostream& operator<<(ostream& cout, MyInteger myint);

    public:
    MyInteger(){
        m_Num = 0;
    }
    // 重载前置++运算符 返回引用而不是返回值 是为了可以一直对一个数据进行递增
    MyInteger& operator++(){
        // 先递增
        m_Num++;
        // 再将自身返回
        return *this;
    }

    // 重载后置++运算符 返回值而不是返回引用 因为返回的temp是局部对象的引用，局部对象销毁后就是非法引用了
    // 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;  // 2
    cout << myint << endl;        // 2
}


void test02(){
    MyInteger myint;
    cout << myint++ << endl;  // 0    
    cout << myint << endl;   // 1

    int a = 0;
    // cout << (a++)++ << endl;  // 0  // (a++)++是报错的，所以我们自己实现后置递增也不用考虑这种情况
    cout << a << endl;   // 1
}


int main(){
    test01();
    test02();
}

4.递减运算符重载

#include <iostream>
using namespace std;
#include <string>

// 首先需要重载左移运算符
// 然后实现前置递减和后置递减的--运算符

class MyInteger{

    friend ostream& operator<<(ostream& cout, MyInteger myint);

    public:
    MyInteger(){
        m_Num = 0;
    }
    // 前置递减
    MyInteger& operator--(){
        m_Num--;
        return *this;
    }

    // 后置递减
    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;  // -2
    cout << myint << endl;  // -2

}

void test02(){
    MyInteger myint;
    cout << myint-- << endl;  // 0
    cout << myint << endl;  // -1
}


int main(){
    test01();
    test02();
}

5.赋值运算符重载

#include <iostream>
using namespace std;
#include <string>

// 赋值运算符重载
// 目的：编译器提供的赋值运算符操作是浅拷贝操作
//      当对象间的拷贝例如p1 = p2; 这种，当涉及到堆区数据的拷贝时，会出现内存重复释放的错误
//      因此需要赋值运算符重载，进行深拷贝的操作

class Person{

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

    ~Person(){
        // 因为开辟了堆区内存 所以要实现析构函数手动释放
        if(m_Age != NULL){
            delete m_Age;
            m_Age = NULL;
        }
    }

    // 重载赋值运算符
    Person& operator=(Person &p){
        // 编译器提供是的浅拷贝 m_Age = p.m_Age； 
        // 但我们不应该这样做

        // 应该先判断是否有属性在堆区(因为Person p2(20);后已经在堆区开辟过内存了)
        // 如果有 先释放干净 然后再深拷贝
        if(m_Age != NULL){
            delete m_Age;
            m_Age = NULL;
        }
        m_Age = new int(*p.m_Age);  // 深拷贝 重新在堆区申请一块内存空间，然后让自身指针去指向这个新的空间

        return *this; // 返回自身，从而可以链式编程
    }

    int *m_Age; // 使用指针，这里年龄的真实数据要开辟到堆区
};


void test01(){
    // 测试对象间的赋值操作
    cout << "test02" << endl;

    Person p1(18);
    Person p2(20);

    p2 = p1; // 赋值操作，当释放堆区内存时也会出现内存重复释放的错误，因此需要赋值运算符重载

    cout << "p1 的年龄为 " << *p1.m_Age << endl;   // 18
    cout << "p2 的年龄为 " << *p2.m_Age << endl;   // 18
}

void test02(){
    // 测试链式赋值操作
    cout << "test02" << endl;

    Person p1(18);
    Person p2(20);
    Person p3(30);

    p3 = p2 = p1;

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

int main(){
    test01();
    test02();
}

6.关系运算符重载

#include <iostream>
using namespace std;
#include <string>

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

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;
        }
        else{
            return false;
        }
    }

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

    string m_Name;
    int m_Age;

};

void test01(){
    Person p1("Tom", 18);
    Person p2("Sun", 18);

    if (p1==p2){
        cout << "对象p1 == p2" << endl;
    }
    else{
        cout << "对象p1 != p2" << endl;
    }
    if (p1!=p2){
        cout << "对象p1 != p2" << endl;
    }
    else{
        cout << "对象p1 == p2" << endl;
    }

}

int main(){
    test01();

}

7.函数调用运算符重载

#include <iostream>
using namespace std;
#include <string>

// 函数调用运算符()也能发生重载
// 由于重载后使用的方式非常像函数的调用，因此称为 仿函数
// 仿函数 没有固定写法 非常灵活   ———— 在STL中用到的比较多

// ----------------------------------------------------------------------------------
// 打印输出类
class MyPrint{
    public:

    // 重载函数调用运算符
    void operator()(string test){
        cout << test << endl;
    }

};

// 正常打印输出函数
void print(string test){
    cout << test << endl;
}


void test01(){
    MyPrint myprint;
    myprint("hello world");
    // ^
    // I   上面是重载的仿函数 下面是正常函数 两者调用形式非常像！
    // v
    print("hello world");
}
// ----------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------
// 仿函数非常灵活 没有一个固定的写法 可以依据需求编写
// 加法类
class MyAdd{
    public:
    int operator()(int num1, int num2){
        return num1+num2;
    }

};
void test02(){
    
    MyAdd myadd;
    int result = myadd(20,30);
    cout << result << endl;

    // 匿名函数对象 
    // MyAdd()创建出了一个匿名函数对象，可以省去创建对象的步骤
    cout << MyAdd()(20,30) << endl;
}
// ----------------------------------------------------------------------------------

int main(){
    test01();
    test02();
}