C++入门——运算符重载

参考链接

1. https://www.bilibili.com/video/BV1et411b73Z?p=121

运算符重载

概念

对已有的运算符重新进行定义，赋予另一种功能，以适应不同的数据类型

注意事项

1. 对于内置的函数类型的表达式的运算符是不可能改变的
2. 不要滥用运算符重载（比如加法重载为减法）

加号运算符重载

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

通过成员函数重载+号

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;
}

左移运算符重载

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

通过成员函数重载

利用成员函数重载左移运算符如下，调用时使用p.operator<<(cout)，简化版本p << cout;

但这种方式无法实现cout在左侧，所以不会利用成员函数重载<<运算符

ostream& operator<<(ostream &cout)
{

}

通过全局函数重载

本质上是operator<<(cout, p)，简化为cout << p;

//cout只能有一个，所以只能用引用的方式。
ostream& operator<<(ostream &cout, Person &p)
{
    cout << "m_A = " << p.m_A << " m_B = " << p.m_B;
    return cout;
}

递增运算符重载

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

前置递增返回引用，后置递增返回值。前置递增和后置递增使用int占位参数来区分

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

    //重载前置++运算符
    MyInteger& operator++()
    {
        m_Num++;
        return *this
    }
    //重载后置++运算符
    MyInteger operator++(int) //int 代表占位参数，可以用于区分前置和后置递增
    {
        //先记录当时结果
        MyInteger temp = *this;
        //后递增
        m_Num++;
        return temp;
    }
private:
    int m_Num;
};

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

void test()
{
    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)
        {
            delete m_Age;
            m_Age = NULL;
        }
    }

    //重载赋值运算符
    Person& operator=(Person &p)
    {
        //编译器实现的是浅拷贝
        //m_Age = p.m_Age;
        
        //应该先判断是否有属性在堆区，如果有限释放干净，然后再进行深拷贝
        if (m_Age != NULL)
        {
            delete m_Age;
            m_Age = NULL;
        }

        //深拷贝
        m_Age = new int(*p.m_Age);
        return *this;
    }

    int *m_Age;
};

void test()
{
    Person p1(18);
    Person p2(20);

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

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

int main()
{
    test();
    system("pause");
    return 0;
}

关系运算符的重载

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

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

    // 重载!=号
    bool operator!=(Person &p)
    {
        if (this->m_Name == p.m_Name)
        {
            return false;
        }
        return true;
    }
    string m_Name;
    int m_Age;
};

函数调用运算符重载

1. 函数调用运算符()也可以重载
2. 由于重载后使用的方式非常像函数的调用，因此称为仿函数
3. 仿函数没有固定写法，非常灵活

//打印输出类
class MyPrint
{
public:
    //重载函数调用运算符
    void operator()(string test)
    {
        cout << test << endl;
    }
};
void test()
{
    MyPrint myPrint;
    myPrint("hello world");
}

//加法类
class MyAdd
{
public:
    int operator()(int num1, int num2)
    {
        return num1 + num2;
    }
};

void test()
{
    MyAdd myadd;
    int ret = myadd(100, 100);
    cout << "ret = " << ret << endl;
    
    //匿名函数对象
    cout << MyAdd()(100, 100) << endl;
}