• C++零碎记录（八）

    14. 运算符重载简介

    14.1 运算符重载简介

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

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

    14.2 加号运算符重载

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

    1. #include <iostream>
    2. using namespace std;
    3.  
    4. //加号运算符重载
    5. class Person
    6. {
    7. public:
    8.  
    9.     //1、成员函数重载+号
    10.     Person operator+(Person& p)
    11.     {
    12.         Person temp;
    13.         temp.m_A = this->m_A + p.m_A;
    14.         temp.m_B = this->m_B + p.m_B;
    15.         return temp;
    16.     }
    17.     int m_A;
    18.     int m_B;
    19. };
    20.  
    21. /*
    22. //全局函数重载+号
    23. Person operator+(Person &p1, Person &p2)
    24. {
    25.     Person temp;
    26.     temp.m_A = p1.m_A + p2.m_A;
    27.     temp.m_B = p1.m_B + p2.m_B;
    28.     return temp;
    29. }
    30. */
    31.  
    32. //函数重载的版本
    33. Person operator+(Person& p1, int num)
    34. {
    35.     Person temp;
    36.     temp.m_A = p1.m_A + num;
    37.     temp.m_B = p1.m_B + num;
    38.     return temp;
    39. }
    40.  
    41. void test01()
    42. {
    43.     Person p1;
    44.     p1.m_A = 10;
    45.     p1.m_B = 10;
    46.     Person p2;
    47.     p2.m_A = 10;
    48.     p2.m_B = 10;
    49.  
    50.     //成员函数重载本质调用 
    51.     //Person p3 = p1.operator+(p2);
    52.     
    53.     //全局函数重载本质调用 
    54.     //Person p3 = operator+(p1,p2);
    55.     
    56.     Person p3 = p1 + p2; //重载本质被简化后的形式
    57.  
    58.     //运算符重载，也可以发生函数重载
    59.  
    60.     Person p4 = p1 + 10; //Person + int
    61.  
    62.     cout << "p3.m_A：" << p3.m_A << endl;
    63.     cout << "p3.m_B：" << p3.m_B << endl;
    64.  
    65.     cout << "p4.m_A：" << p4.m_A << endl;
    66.     cout << "p4.m_B：" << p4.m_B << endl;
    67.  
    68. }
    69.  
    70.  
    71. int main()
    72. {
    73.     test01();
    74.  
    75.     system("pause");
    76.  
    77.     return 0;
    78.  
    79. }

    运行结果：

    • p3.m_A：20
    • p3.m_B：20
    • p4.m_A：20
    • p4.m_B：20
    • 请按任意键继续. . .

    14.3 左移运算符重载

    ① 左移运算符重载：可以输出自定义数据类型。

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

    1. #include 
    2. using namespace std;
    3.  
    4. //左移运算符
    5. class Person
    6. {
    7.  
    8.     friend ostream& operator<<(ostream& out, Person& p);	
    9.  
    10. public:
    11.     Person(int a, int b)
    12.     {
    13.         m_A = a;
    14.         m_B = b;
    15.     }
    16.  
    17.     /*
    18.     //利用成员函数重载 左移运算符  p.operator<<(cout) 简化版本 p << cout
    19.     //成员函数不能利用重载<<运算符，因为无法实现cout在左侧
    20.     //当不知道返回值是什么类型的时候，可以先写个void，以后再改
    21.     void operator<<(Person& p)
    22.     {
    23.         
    24.     }
    25.     */
    26.     
    27. private:
    28.     int m_A;
    29.     int m_B;
    30. };
    31.  
    32. //只能利用全局函数重载左移运算符
    33. //如果返回类型为void，那么就无法无限追加，也没有办法在后面添加换行符
    34. ostream & operator<<(ostream &cout, Person &p) //本质 operator << (cout , p) , 简化 cout << p
    35.                                                //cout是别名，这里可以取out、kn...
    36.                                                //cout为ostream输出流数据类型                                                    
    37. {
    38.     cout << "m_A= " << p.m_A << " m_B=" << p.m_B;
    39.     return cout;
    40. }
    41.  
    42. void test01()
    43. {
    44.     Person p(10,10);
    45.  
    46.     cout << p << " hello world" << endl;
    47. }
    48.  
    49.  
    50. int main()
    51. {
    52.     test01();
    53.  
    54.     system("pause");
    55.  
    56.     return 0;
    57.  
    58. }

    运行结果：

    • m_A= 10 m_B=10 hello world
    • 请按任意键继续. . .

    14.4 递增运算符

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

    ② 前置递增返回的是引用，后置递增返回的是值。

    1. #include 
    2. using namespace std;
    3.  
    4. //重载递增运算符
    5.  
    6. class MyInteger
    7. {
    8.     friend ostream& operator<<(ostream& cout, MyInteger myint);
    9.  
    10. public:
    11.     MyInteger()
    12.     {
    13.         m_Num = 0;
    14.     }
    15.     
    16.     //重载前置++运算符,返回引用是为了一直对一个数据进行递增操作,而返回值并不是一直对一个数据进行递增操作                    
    17.     MyInteger& operator++()
    18.     {
    19.         //先进行++运算
    20.         m_Num++;
    21.  
    22.         //再将自身做一个返回
    23.         return *this;  //把自身做一个返回
    24.     }
    25.  
    26.     //重载后置++运算符 int代表占位参数，可以用于区分前置和后置递增
    27.     //后置递增不能返回引用，因为temp是局部变量，如果返回temp，当程序运行完后变量就释放了，再调用temp就是非法操作了           
    28.     MyInteger operator++(int)
    29.     {
    30.         //先记录当时结果
    31.         MyInteger temp = *this;
    32.         //后 递增
    33.         m_Num++;
    34.         //最后将记录结果做返回
    35.         return temp;
    36.     }
    37. private:
    38.     int m_Num;
    39. };
    40.  
    41. //只能利用全局函数重载左移运算符
    42. ostream & operator<<(ostream &cout, MyInteger myint) //本质 operator << (cout , p) , 简化 cout << p
    43.                                                      //cout是别名，这里可以取out、kn...
    44.                                                      //cout为ostream输出流数据类型                                               
    45. {
    46.     cout << myint.m_Num;
    47.  
    48.     return cout;
    49. }
    50.  
    51. void test01()
    52. {
    53.     MyInteger myint;
    54.  
    55.     cout << ++(++myint) << endl;
    56.     cout << myint << endl;
    57. }
    58.  
    59. void test02()
    60. {
    61.     MyInteger myint;
    62.  
    63.     cout << myint++ << endl;
    64.     cout << myint   << endl;
    65.  
    66. }
    67.  
    68. int main()
    69. {
    70.     test01();
    71.     test02();
    72.  
    73.     /*
    74.     int a = 0;
    75.     cout << ++(++a) << endl; //运行结果为2
    76.     cout << a << endl;       //运行结果为2，表示一直对一个数据进行递增
    77.     */
    78.  
    79.     system("pause");
    80.  
    81.     return 0;
    82.  
    83. }

    运行结果：

    • 2
    • 2
    • 0
    • 1
    • 请按任意键继续. . .

    14.5 赋值运算符

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

    1. 默认构造函数(无参，函数体为空)
    2. 默认析构函数(无参，函数体为空)
    3. 默认拷贝构造函数，对属性进行值拷贝
    4. 赋值运算符operator=，对属性进行值拷贝
    5. 如果类中有属性指向堆区，做赋值操作时也会出现浅拷贝问题。 
    1. #include 
    2. using namespace std;
    3.  
    4. //重载赋值运算符
    5.  
    6. class Person
    7. {
    8. public:
    9.     Person(int age)
    10.     {
    11.         m_Age = new int(age);
    12.     }
    13.     
    14.     ~Person()
    15.     {
    16.         if (m_Age != NULL)
    17.         {
    18.             delete m_Age;
    19.             m_Age = NULL;
    20.         }
    21.     }
    22.  
    23.     //重载 赋值运算符
    24.     //如果返回的是值，而不是引用，是创建一个拷贝函数，返回的是一个副本，而不是自身
    25.     Person& operator=(Person& p)
    26.     {
    27.         //编译器默认是提供浅拷贝
    28.         //m_Age = p.m_Age;
    29.  
    30.         //浅拷贝带来的问题是，当创建数据在堆区时，析构代码导致内存重复释放，报错
    31.  
    32.         //应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
    33.         if (m_Age != NULL)
    34.         {
    35.             delete m_Age;
    36.             m_Age = NULL;
    37.         }
    38.  
    39.         //深拷贝
    40.         m_Age = new int(*p.m_Age);
    41.  
    42.         //返回对象本身
    43.         return *this;
    44.     }
    45.  
    46.     int *m_Age;
    47. };
    48.  
    49. void test01()
    50. {
    51.     Person p1(18);
    52.  
    53.     Person p2(20);
    54.  
    55.     Person p3(23);
    56.  
    57.     p3 = p2 = p1; //赋值操作
    58.  
    59.     cout << "p1的年龄为：" << *p1.m_Age << endl;
    60.  
    61.     cout << "p2的年龄为：" << *p2.m_Age << endl;
    62.  
    63.     cout << "p3的年龄为：" << *p3.m_Age << endl;
    64.  
    65.  
    66. }
    67.  
    68. int main()
    69. {
    70.     test01();
    71.  
    72.     /*
    73.     
    74.     int a = 10;
    75.     int b = 20;
    76.     int c = 30;
    77.     
    78.     c = b = a;
    80.     cout << "a= " << a << endl;
    81.     cout << "b= " << b << endl;
    82.     cout << "c= " << c << endl;
    83.     */
    84.  
    85.     system("pause");
    86.  
    87.     return 0;
    88.  
    89. }

    运行结果：

    • p1的年龄为：18
    • p2的年龄为：18
    • p3的年龄为：18
    • 请按任意键继续. . .

    14.6 关系重载运算符

    1. #include 
    2. using namespace std;
    3. #include
    4.  
    5. //重载关系运算符
    6.  
    7. class Person
    8. {
    9. public:
    10.     Person(string name, int age)
    11.     {
    12.         m_Name = name;
    13.         m_Age = age;
    14.     }
    15.  
    16.     //重载 == 号
    17.     bool operator==(Person& p)
    18.     {
    19.         if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
    20.         {
    21.             return true;
    22.         }
    23.         return false;
    24.     }
    25.  
    26.     bool operator!=(Person& p)
    27.     {
    28.         if (this->m_Name != p.m_Name && this->m_Age != p.m_Age)
    29.         {
    30.             return true;
    31.         }
    32.         return false;
    33.     }
    34.  
    35.     string m_Name;
    36.     int m_Age;
    37. };
    38.  
    39. void test01()
    40. {
    41.     Person p1("Tom", 17);
    42.  
    43.     Person p2("Jerry", 18);
    44.  
    45.     if (p1 == p2)
    46.     {
    47.         cout << "p1和p2是相等的！" << endl;
    48.     }
    49.     else
    50.     {
    51.         cout << "p1和p2是不相等的！" << endl;
    52.  
    53.     }
    54.  
    55.     if (p1 != p2)
    56.     {
    57.         cout << "p1和p2是不相等的！" << endl;
    58.     }
    59.     else
    60.     {
    61.         cout << "p1和p2是相等的！" << endl;
    62.  
    63.     }
    64.  
    65.  
    66. }
    67.  
    68. int main()
    69. {
    70.     test01();
    71.     
    72.     system("pause");
    73.  
    74.     return 0;
    75.  
    76. }

    运行结果：

    • p1和p2是不相等的！
    • p1和p2是不相等的！
    • 请按任意键继续. . .

    14.7 函数调用运算符重载

    ① 函数调用运算符()也可以重载。

    ② 由于重载后使用的方式非常像函数的调用，因此称为仿函数。

    ③ 仿函数没有固定写法，非常灵活。

    1. #include 
    2. using namespace std;
    3. #include
    4.  
    5. //函数调用运算符重载
    6.  
    7. //打印输出类
    8. class MyPrint
    9. {
    10. public:
    11.  
    12.     //重载函数调用运算符
    13.     void operator()(string test)
    14.     {
    15.         cout << test << endl;
    16.     }
    17.  
    18. };
    19.  
    20. //正常函数
    21. void MyPrint02(string test)
    22. {
    23.     cout << test << endl;
    24. }
    25.  
    26. void test01()
    27. {
    28.     MyPrint myPrint;
    29.  
    30.     myPrint("hello world");
    31.  
    32. }
    33.  
    34. //仿函数非常灵活，没有固定的写法
    35. //加法类
    36. class MyAdd
    37. {
    38. public:
    39.     int operator()(int num1, int num2)
    40.     {
    41.         return num1 + num2;
    42.     }
    43. };
    44.  
    45. void test02()
    46. {
    47.     MyAdd myadd;
    48.     int ret = myadd(100,100);
    49.     cout << "ret = " << ret << endl;
    50.  
    51.     //匿名函数对象
    52.     cout << MyAdd()(100, 100) << endl;
    53.  
    54.     // MyAdd()为创建一个匿名对象，匿名对象的特点为当前行执行完立即释放
    55. }
    56.  
    57. int main()
    58. {
    59.     test01();
    60.  
    61.     MyPrint02("hello world"); //由于使用起来非常类似于函数调用，因此称为仿函数
    62.  
    63.     test02();
    64.  
    65.     system("pause");
    66.  
    67.     return 0;
    68.  
    69. }

    运行结果：

    • hello world
    • hello world
    • ret = 200
    • 200
    • 请按任意键继续. . .

    链接：https://www.zhihu.com/question/437657370/answer/1692846096

  • 相关阅读:
    Es集群部署
    Dextran-ALK,葡聚糖-炔基|炔基修饰葡聚糖,葡萄糖/乳糖基/黄原胶/岩藻多糖/木聚糖
    【2024年最新】NodeMCU-ESP8266刷AT固件教程——适用于esp-12E和esp-12F
    电梯物联网之梯控相机方案-防止电瓶车进电梯
    python数学建模--线性规划问题案例及求解
    JSP EL表达式的基本语法及运算符的优先级（一览表）
    【Linux系统管理】09 文件系统管理 & 高级文件系统管理
    Android Studio实现一个点餐系统
    Spring Data JPA 之 DataSource 详解及其加载过程
    mysql数据库优化之数据库非sql优化
  • 原文地址：https://blog.csdn.net/qq18218628646/article/details/132733463