• C++day4

    1.算术运算符重载

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. //算术运算符
    6.  
    7. class Person
    8. {
    9.     friend const Person operator+(const Person &L,const Person &R);
    10.     friend const Person operator-(const Person &L,const Person &R);
    11.     friend const Person operator*(const Person &L,const Person &R);
    12.     friend const Person operator/(const Person &L,const Person &R);
    13.     friend const Person operator%(const Person &L,const Person &R);
    14.  
    15. private:
    16.     int a;
    17.     int b;
    18.  
    19. public:
    20.     Person() {}
    21.     Person(int a,int b):a(a),b(b)
    22.     {}
    23.  
    24.     void show();
    25.  
    26.     //成员函数实现+运算符重载
    27. //    const Person operator+(const Person &p) const
    28. //    {
    29. //        Person temp;
    30. //        temp.a=a+p.a;
    31. //        temp.b=b+p.b;
    32. //        return temp ;
    33. //    }
    34.  
    35.       //成员函数实现-运算符重载
    36. //    const Person operator-(const Person &p) const
    37. //    {
    38. //        Person temp;
    39. //        temp.a=a-p.a;
    40. //        temp.b=b-p.b;
    41. //        return temp ;
    42. //    }
    43.  
    44.     //成员函数实现*运算符重载
    45. //    const Person operator*(const Person &p) const
    46. //    {
    47. //        Person temp;
    48. //        temp.a=a*p.a;
    49. //        temp.b=b*p.b;
    50. //        return temp ;
    51. //    }
    52.  
    53.     //成员函数实现/运算符重载
    54. //    const Person operator/(const Person &p) const
    55. //    {
    56. //        Person temp;
    57. //        temp.a=a/p.a;
    58. //        temp.b=b/p.b;
    59. //        return temp ;
    60. //    }
    61.  
    62.     //成员函数实现%运算符重载
    63. //    const Person operator%(const Person &p) const
    64. //    {
    65. //        Person temp;
    66. //        temp.a=a%p.a;
    67. //        temp.b=b%p.b;
    68. //        return temp ;
    69. //    }
    70.  
    71. };
    72.  
    73. //全局函数实现+运算符重载
    74. const Person operator+(const Person &L,const Person &R)
    75. {
    76.     Person temp;
    77.     temp.a=L.a+R.a;
    78.     temp.b=L.b+R.b;
    79.     return temp ;
    80. }
    81.  
    82. //全局函数实现-运算符重载
    83. const Person operator-(const Person &L,const Person &R)
    84. {
    85.     Person temp;
    86.     temp.a=L.a-R.a;
    87.     temp.b=L.b-R.b;
    88.     return temp ;
    89. }
    90.  
    91. //全局函数实现*运算符重载
    92. const Person operator*(const Person &L,const Person &R)
    93. {
    94.     Person temp;
    95.     temp.a=L.a*R.a;
    96.     temp.b=L.b*R.b;
    97.     return temp ;
    98. }
    99.  
    100. //全局函数实现/运算符重载
    101. const Person operator/(const Person &L,const Person &R)
    102. {
    103.     Person temp;
    104.     temp.a=L.a/R.a;
    105.     temp.b=L.b/R.b;
    106.     return temp ;
    107. }
    108.  
    109. //全局函数实现%运算符重载
    110. const Person operator%(const Person &L,const Person &R)
    111. {
    112.     Person temp;
    113.     temp.a=L.a%R.a;
    114.     temp.b=L.b%R.b;
    115.     return temp ;
    116. }
    117.  
    118. void Person::show()
    119. {
    120.     cout << "a= " << a << "  b= " << b << endl;
    121. }
    122.  
    123. int main()
    124. {
    125.     Person p1(10,10);
    126.     Person p2(10,10);
    127.     Person p3=p1+p2;
    128.     p3.show();
    129.  
    130.     Person p4=p1-p2;
    131.     p4.show();
    132.  
    133.     Person p5=p1*p2;
    134.     p5.show();
    135.  
    136.     Person p6=p1/p2;
    137.     p6.show();
    138.  
    139.     Person p7=p1%p2;
    140.     p7.show();
    141.  
    142.     return 0;
    143. }

    2.关系运算符重载

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. //关系运算符
    6.  
    7. class Person
    8. {
    9.     friend bool operator>(const Person &L,const Person &R);
    10.     friend bool  operator>=(const Person &L,const Person &R);
    11.     friend bool  operator<(const Person &L,const Person &R);
    12.     friend bool  operator<=(const Person &L,const Person &R);
    13.     friend bool  operator!=(const Person &L,const Person &R);
    14.     friend bool  operator==(const Person &L,const Person &R);
    15.  
    16. private:
    17.     int a;
    18.     int b;
    19.  
    20. public:
    21.     Person() {}
    22.     Person(int a,int b):a(a),b(b)
    23.     {}
    24.  
    25.     void show();
    26.  
    27.     //关系函数实现>运算符重载
    28. //    bool  operator>(const Person &R) const
    29. //    {
    30. //        if(a>R.a && b>R.b)
    31. //        {
    32. //            return true;
    33. //        }
    34. //        else
    35. //        {
    36. //            return false;
    37. //        }
    38. //    }
    39.  
    40.     //关系函数实现>=运算符重载
    41. //    bool  operator>=(const Person &R) const
    42. //    {
    43. //        if(a>=R.a && b>=R.b)
    44. //        {
    45. //            return true;
    46. //        }
    47. //        else
    48. //        {
    49. //            return false;
    50. //        }
    51. //    }
    52.  
    53.     //关系函数实现<运算符重载
    54. //    bool  operator<(const Person &R) const
    55. //    {
    56. //        if(a
    57. //        {
    58. //            return true;
    59. //        }
    60. //        else
    61. //        {
    62. //            return false;
    63. //        }
    64. //    }
    65.  
    66.     //关系函数实现<=运算符重载
    67. //    bool  operator<=(const Person &R) const
    68. //    {
    69. //        if(a<=R.a && b<=R.b)
    70. //        {
    71. //            return true;
    72. //        }
    73. //        else
    74. //        {
    75. //            return false;
    76. //        }
    77. //    }
    78.  
    79.     //关系函数实现!=运算符重载
    80. //    bool  operator!=(const Person &R) const
    81. //    {
    82. //        if(a!=R.a && b!=R.b)
    83. //        {
    84. //            return true;
    85. //        }
    86. //        else
    87. //        {
    88. //            return false;
    89. //        }
    90. //    }
    91.  
    92.     //关系函数实现==运算符重载
    93. //    bool  operator==(const Person &R) const
    94. //    {
    95. //        if(a==R.a && b==R.b)
    96. //        {
    97. //            return true;
    98. //        }
    99. //        else
    100. //        {
    101. //            return false;
    102. //        }
    103. //    }
    104.  
    105.  
    106. };
    107.  
    108. //全局函数实现>运算符重载
    109. bool  operator>(const Person &L,const Person &R)
    110. {
    111.   if(L.a>R.a && L.b>R.b)
    112.   {
    113.       return true;
    114.   }
    115.   else
    116.   {
    117.       return false;
    118.   }
    119. }
    120.  
    121. //全局函数实现>=运算符重载
    122. bool  operator>=(const Person &L,const Person &R)
    123. {
    124.   if(L.a>=R.a && L.b>=R.b)
    125.   {
    126.       return true;
    127.   }
    128.   else
    129.   {
    130.       return false;
    131.   }
    132. }
    133.  
    134. //全局函数实现<运算符重载
    135. bool  operator<(const Person &L,const Person &R)
    136. {
    137.   if(L.a
    138.   {
    139.       return true;
    140.   }
    141.   else
    142.   {
    143.       return false;
    144.   }
    145. }
    146.  
    147. //全局函数实现<=运算符重载
    148. bool  operator<=(const Person &L,const Person &R)
    149. {
    150.   if(L.a<=R.a && L.b<=R.b)
    151.   {
    152.       return true;
    153.   }
    154.   else
    155.   {
    156.       return false;
    157.   }
    158. }
    159.  
    160. //全局函数实现!=运算符重载
    161. bool  operator!=(const Person &L,const Person &R)
    162. {
    163.   if(L.a!=R.a && L.b!=R.b)
    164.   {
    165.       return true;
    166.   }
    167.   else
    168.   {
    169.       return false;
    170.   }
    171. }
    172.  
    173. //全局函数实现==运算符重载
    174. bool  operator==(const Person &L,const Person &R)
    175. {
    176.   if(L.a==R.a && L.b==R.b)
    177.   {
    178.       return true;
    179.   }
    180.   else
    181.   {
    182.       return false;
    183.   }
    184. }
    185.  
    186. int main()
    187. {
    188.     Person p1(20,20);
    189.     Person p2(10,10);
    190.     if(p1>p2)
    191.     {
    192.         cout << "p1>p2" << endl;
    193.     }
    194.  
    195.     if(p1>=p2)
    196.     {
    197.         cout << "p1>=p2" << endl;
    198.     }
    199.  
    200.     if(p2
    201.     {
    202.         cout << "p2 << endl;
    203.     }
    204.  
    205.     if(p2<=p1)
    206.     {
    207.         cout << "p2<=p1" << endl;
    208.     }
    209.  
    210.     if(p2!=p1)
    211.     {
    212.         cout << "p2!=p1" << endl;
    213.     }
    214.  
    215.     Person p3(100,100);
    216.     Person p4(100,100);
    217.     if(p3==p4)
    218.     {
    219.         cout << "p3==p4" << endl;
    220.     }
    221.  
    222.     return 0;
    223. }

    3.赋值运算符重载

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. //赋值运算符
    6.  
    7. class Person
    8. {
    9.     friend Person& operator+=(Person &L,const Person &R);
    10.     friend Person& operator-=(Person &L,const Person &R);
    11.     friend Person& operator*=(Person &L,const Person &R);
    12.     friend Person& operator/=(Person &L,const Person &R);
    13.     friend Person& operator%=(Person &L,const Person &R);
    14.  
    15. private:
    16.     int a;
    17.     int b;
    18.  
    19. public:
    20.     Person() {}
    21.     Person(int a,int b):a(a),b(b)
    22.     {}
    23.  
    24.     void show();
    25.  
    26.  
    27.  
    28.     //赋值函数实现+=运算符重载
    29. //    Person& operator+=(const Person &R)
    30. //    {
    31. //        a+=R.a;
    32. //        b+=R.b;
    33. //        return *this;
    34. //    }
    35.  
    36. //    void show()
    37. //    {
    38. //        cout << "a= " << a << "  b= " << b << endl;
    39. //    }
    40.  
    41.  
    42.     //赋值函数实现-=运算符重载
    43. //    Person& operator-=(const Person &R)
    44. //    {
    45. //        a-=R.a;
    46. //        b-=R.b;
    47. //        return *this;
    48. //    }
    49.  
    50.     //赋值函数实*=运算符重载
    51. //    Person& operator*=(const Person &R)
    52. //    {
    53. //        a*=R.a;
    54. //        b*=R.b;
    55. //        return *this;
    56. //    }
    57.  
    58.     //赋值函数实/=运算符重载
    59. //    Person& operator/=(const Person &R)
    60. //    {
    61. //        a/=R.a;
    62. //        b/=R.b;
    63. //        return *this;
    64. //    }
    65.  
    66.     //赋值函数实%=运算符重载
    67. //    Person& operator%=(const Person &R)
    68. //    {
    69. //        a%=R.a;
    70. //        b%=R.b;
    71. //        return *this;
    72. //    }
    73.  
    74.     //赋值函数实=运算符重载
    75.     Person& operator=(const Person &R)
    76.     {
    77.         a=R.a;
    78.         b=R.b;
    79.         return *this;
    80.     }
    81.  
    82. };
    83.  
    84. //全局函数实现+=运算符重载
    85. Person& operator+=(Person &L,const Person &R)
    86. {
    87.     L.a+=R.a;
    88.     L.b+=R.b;
    89.     return L;
    90. }
    91.  
    92. //全局函数实现-=运算符重载
    93. Person& operator-=(Person &L,const Person &R)
    94. {
    95.     L.a-=R.a;
    96.     L.b-=R.b;
    97.     return L;
    98. }
    99.  
    100. //全局函数实现*=运算符重载
    101. Person& operator*=(Person &L,const Person &R)
    102. {
    103.     L.a*=R.a;
    104.     L.b*=R.b;
    105.     return L;
    106. }
    107.  
    108. //全局函数实现/=运算符重载
    109. Person& operator/=(Person &L,const Person &R)
    110. {
    111.     L.a/=R.a;
    112.     L.b/=R.b;
    113.     return L;
    114. }
    115.  
    116. //全局函数实现%=运算符重载
    117. Person& operator%=(Person &L,const Person &R)
    118. {
    119.     L.a%=R.a;
    120.     L.b%=R.b;
    121.     return L;
    122. }
    123.  
    124.  
    125.  
    126. void Person::show()
    127. {
    128.     cout << "a= " << a << "  b= " << b << endl;
    129. }
    130.  
    131. int main()
    132. {
    133.     Person p1(0,0);
    134.     Person p2(1,1);
    135.     p1+=p2;
    136.     p1.show();
    137.  
    138.     Person p3(2,2);
    139.     Person p4(0,0);
    140.     p3-=p4;
    141.     p3.show();
    142.  
    143.     Person p5(3,3);
    144.     Person p6(1,1);
    145.     p5*=p6;
    146.     p5.show();
    147.  
    148.     Person p7(4,4);
    149.     Person p8(1,1);
    150.     p7/=p8;
    151.     p7.show();
    152.  
    153.     Person p9(5,5);
    154.     Person p10(1,1);
    155.     p9/=p10;
    156.     p9.show();
    157.  
    158.     Person p11(6,6);
    159.     Person p12(7,7);
    160.     p11%=p12;
    161.     p11.show();
    162.  
    163.     p11=p12;
    164.     p11.show();
    165.  
    166.     return 0;
    167. }

    思维导图： 

  • 相关阅读:
    Spring注解@Qualifier的详细用法你知道几种「扩展点实战系列」- 第444篇
    华为数通方向HCIP-DataCom H12-831题库(单选题：201-220）
    tkinter显示图片
    【JVM】JVM与Java体系结构
    【3】Docker镜像相关命令
    视频编码基础知识
    阿赵UE引擎C++编程学习笔记——用户输入监听
    熟悉HotSpot中的对象
    双指针的问题解法以及常见的leetcode例题。
    python的for循环语句的用法及实例
  • 原文地址：https://blog.csdn.net/2301_79218296/article/details/133755563