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

1 加号运算符重载

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

  1. class Person {
  2. public:
  3.     Person() {};
  4.     Person(int a, int b)
  5.     {
  6.         this->m_A = a;
  7.         this->m_B = b;
  8.     }
  9.     //成员函数实现 + 号运算符重载
  10.     Person operator+(const Person& p) {
  11.         Person temp;
  12.         temp.m_A = this->m_A + p.m_A;
  13.         temp.m_B = this->m_B + p.m_B;
  14.         return temp;
  15.     }
  18. public:
  19.     int m_A;
  20.     int m_B;
  21. };
  23. //全局函数实现 + 号运算符重载
  24. //Person operator+(const Person& p1, const Person& p2) {
  25. //    Person temp(0, 0);
  26. //    temp.m_A = p1.m_A + p2.m_A;
  27. //    temp.m_B = p1.m_B + p2.m_B;
  28. //    return temp;
  29. //}
  31. //运算符重载 可以发生函数重载 
  32. Person operator+(const Person& p2, int val)  
  33. {
  34.     Person temp;
  35.     temp.m_A = p2.m_A + val;
  36.     temp.m_B = p2.m_B + val;
  37.     return temp;
  38. }
  40. void test() {
  42.     Person p1(10, 10);
  43.     Person p2(20, 20);
  45.     //成员函数方式
  46.     Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
  47.     cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;
  50.     Person p4 = p3 + 10; //相当于 operator+(p3,10)
  51.     cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;
  53. }
  55. int main() {
  57.     test();
  59.     system("pause");
  61.     return 0;
  62. }

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

总结2：不要滥用运算符重载

2 左移运算符重载

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

  1. class Person {
  2.     friend ostream& operator<<(ostream& out, Person& p);
  4. public:
  6.     Person(int a, int b)
  7.     {
  8.         this->m_A = a;
  9.         this->m_B = b;
  10.     }
  12.     //成员函数 实现不了  p << cout 不是我们想要的效果
  13.     //void operator<<(Person& p){
  14.     //}
  16. private:
  17.     int m_A;
  18.     int m_B;
  19. };
  21. //全局函数实现左移重载
  22. //ostream对象只能有一个
  23. ostream& operator<<(ostream& out, Person& p) {
  24.     out << "a:" << p.m_A << " b:" << p.m_B;
  25.     return out;
  26. }
  28. void test() {
  30.     Person p1(10, 20);
  32.     cout << p1 << "hello world" << endl; //链式编程
  33. }
  35. int main() {
  37.     test();
  39.     system("pause");
  41.     return 0;
  42. }

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

3 递增运算符重载

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

  2. class MyInteger {
  4.     friend ostream& operator<<(ostream& out, MyInteger myint);
  6. public:
  7.     MyInteger() {
  8.         m_Num = 0;
  9.     }
  10.     //前置++
  11.     MyInteger& operator++() {
  12.         //先++
  13.         m_Num++;
  14.         //再返回
  15.         return *this;
  16.     }
  18.     //后置++
  19.     MyInteger operator++(int) {
  20.         //先返回
  21.         MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
  22.         m_Num++;
  23.         return temp;
  24.     }
  26. private:
  27.     int m_Num;
  28. };
  31. ostream& operator<<(ostream& out, MyInteger myint) {
  32.     out << myint.m_Num;
  33.     return out;
  34. }
  37. //前置++ 先++ 再返回
  38. void test01() {
  39.     MyInteger myInt;
  40.     cout << ++myInt << endl;
  41.     cout << myInt << endl;
  42. }
  44. //后置++ 先返回 再++
  45. void test02() {
  47.     MyInteger myInt;
  48.     cout << myInt++ << endl;
  49.     cout << myInt << endl;
  50. }
  52. int main() {
  54.     test01();
  55.     //test02();
  57.     system("pause");
  59.     return 0;
  60. }

总结： 前置递增返回引用，后置递增返回值

4 赋值运算符重载

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

  1. 默认构造函数(无参，函数体为空)
  2. 默认析构函数(无参，函数体为空)
  3. 默认拷贝构造函数，对属性进行值拷贝
  4. 赋值运算符 operator=, 对属性进行值拷贝

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

示例：

  1. class Person
  2. {
  3. public:
  5.     Person(int age)
  6.     {
  7.         //将年龄数据开辟到堆区
  8.         m_Age = new int(age);
  9.     }
  11.     //重载赋值运算符 
  12.     Person& operator=(Person &p)
  13.     {
  14.         if (m_Age != NULL)
  15.         {
  16.             delete m_Age;
  17.             m_Age = NULL;
  18.         }
  19.         //编译器提供的代码是浅拷贝
  20.         //m_Age = p.m_Age;
  22.         //提供深拷贝 解决浅拷贝的问题
  23.         m_Age = new int(*p.m_Age);
  25.         //返回自身
  26.         return *this;
  27.     }
  30.     ~Person()
  31.     {
  32.         if (m_Age != NULL)
  33.         {
  34.             delete m_Age;
  35.             m_Age = NULL;
  36.         }
  37.     }
  39.     //年龄的指针
  40.     int *m_Age;
  42. };
  45. void test01()
  46. {
  47.     Person p1(18);
  49.     Person p2(20);
  51.     Person p3(30);
  53.     p3 = p2 = p1; //赋值操作
  55.     cout << "p1的年龄为：" << *p1.m_Age << endl;
  57.     cout << "p2的年龄为：" << *p2.m_Age << endl;
  59.     cout << "p3的年龄为：" << *p3.m_Age << endl;
  60. }
  62. int main() {
  64.     test01();
  66.     //int a = 10;
  67.     //int b = 20;
  68.     //int c = 30;
  70.     //c = b = a;
  71.     //cout << "a = " << a << endl;
  72.     //cout << "b = " << b << endl;
  73.     //cout << "c = " << c << endl;
  75.     system("pause");
  77.     return 0;
  78. }

5 关系运算符重载

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

示例：

class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->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()
{
    //int a = 0;
    //int b = 0;

    Person a("孙悟空", 18);
    Person b("孙悟空", 18);

    if (a == b)
    {
        cout << "a和b相等" << endl;
    }
    else
    {
        cout << "a和b不相等" << endl;
    }

    if (a != b)
    {
        cout << "a和b不相等" << endl;
    }
    else
    {
        cout << "a和b相等" << endl;
    }
}


int main() {

    test01();

    system("pause");

    return 0;
}

6 函数调用运算符重载

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

示例：

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

};
void test01()
{
    //重载的（）操作符 也称为仿函数
    MyPrint myFunc;
    myFunc("hello world");
}


class MyAdd
{
public:
    int operator()(int v1, int v2)
    {
        return v1 + v2;
    }
};

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

    //匿名对象调用  
    cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
}

int main() {

    test01();
    test02();

    system("pause");

    return 0;
}