• 2023.10.10

    运算符重载

    类外函数实现：

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class Good
    6. {
    7.     //算数
    8.     friend const Good operator*(const Good &L,const Good &R);
    9.     friend const Good operator+(const Good &L,const Good &R);
    10.     friend const Good operator/(const Good &L,const Good &R);
    11.     friend const Good operator-(const Good &L,const Good &R);
    12.     friend const Good operator%(const Good &L,const Good &R);
    13.     //关系
    14.     friend bool operator>(const Good &L,const Good &R);
    15.     friend bool operator>=(const Good &L,const Good &R);
    16.     friend bool operator<(const Good &L,const Good &R);
    17.     friend bool operator<=(const Good &L,const Good &R);
    18.     friend bool operator==(const Good &L,const Good &R);
    19.     //赋值
    20.     friend Good &operator-=(Good &L,const Good &R);
    21.     friend Good &operator+=(Good &L,const Good &R);
    22.     friend Good &operator*=(Good &L,const Good &R);
    23.     friend Good &operator/=(Good &L,const Good &R);
    24.     friend Good &operator%=(Good &L,const Good &R);
    25. private:
    26.     int n;
    27.     int f;
    28.     int a;
    29. public:
    30.     Good(){}
    31.     Good(int n,int f,int a):n(n),f(f),a(a){}
    32.     void show() const
    33.     {
    34.         cout << "n:" << n << endl;
    35.         cout << "f:" << f << endl;
    36.         cout << "a:" << a << endl;
    37.         //cout << "常" << endl;
    38.     }
    39.  
    40. };
    41. //非成员
    42. //算数+
    43. const Good operator+(const Good &L,const Good &R)
    44. {
    45.     Good t;
    46.     t.a=L.a+R.a;
    47.     t.n=L.n+R.n;
    48.     t.f=L.f+R.f;
    49.     return t;
    50. }
    51. //算数*
    52. const Good operator*(const Good &L,const Good &R)
    53. {
    54.     Good t;
    55.     t.a=L.a*R.a;
    56.     t.n=L.n*R.n;
    57.     t.f=L.f*R.f;
    58.     return t;
    59. }
    60. //算数-
    61. const Good operator-(const Good &L,const Good &R)
    62. {
    63.     Good t;
    64.     t.a=L.a-R.a;
    65.     t.n=L.n-R.n;
    66.     t.f=L.f-R.f;
    67.     return t;
    68. }
    69. //算数/
    70. const Good operator/(const Good &L,const Good &R)
    71. {
    72.     Good t;
    73.     t.a=L.a/R.a;
    74.     t.n=L.n/R.n;
    75.     t.f=L.f/R.f;
    76.     return t;
    77. }
    78. //算数%
    79. const Good operator%(const Good &L,const Good &R)
    80. {
    81.     Good t;
    82.     t.a=L.a%R.a;
    83.     t.n=L.n%R.n;
    84.     t.f=L.f%R.f;
    85.     return t;
    86. }
    87. //关系运算<
    88. bool operator<(const Good &L,const Good &R)
    89. {
    90.     if(L.a
    91.         return true;
    92.     }else{
    93.         return false;
    94.     }
    95. }
    96. //关系运算>
    97. bool operator>(const Good &L,const Good &R)
    98. {
    99.     if(L.a>R.a && L.n>R.n && L.f>R.f){
    100.         return true;
    101.     }else{
    102.         return false;
    103.     }
    104. }
    105. //关系运算>=
    106. bool operator>=(const Good &L,const Good &R)
    107. {
    108.     if(L.a>=R.a && L.n>=R.n && L.f>=R.f){
    109.         return true;
    110.     }else{
    111.         return false;
    112.     }
    113. }
    114. //关系运算<=
    115. bool operator<=(const Good &L,const Good &R)
    116. {
    117.     if(L.a<=R.a && L.n<=R.n && L.f<=R.f){
    118.         return true;
    119.     }else{
    120.         return false;
    121.     }
    122. }
    123. //关系运算==
    124. bool operator==(const Good &L,const Good &R)
    125. {
    126.     if(L.a==R.a && L.n==R.n && L.f==R.f){
    127.         return true;
    128.     }else{
    129.         return false;
    130.     }
    131. }
    132. //赋值运算-=
    133. Good &operator-=(Good &L,const Good &R)
    134. {
    135.     L.a-=R.a;
    136.     L.n-=R.n;
    137.     L.f-=R.f;
    138.     return L;
    139. }
    140. //赋值运算+=
    141. Good &operator+=(Good &L,const Good &R)
    142. {
    143.     L.a+=R.a;
    144.     L.n+=R.n;
    145.     L.f+=R.f;
    146.     return L;
    147. }
    148. //赋值运算*=
    149. Good &operator*=(Good &L,const Good &R)
    150. {
    151.     L.a*=R.a;
    152.     L.n*=R.n;
    153.     L.f*=R.f;
    154.     return L;
    155. }
    156. //赋值运算/=
    157. Good &operator/=(Good &L,const Good &R)
    158. {
    159.     L.a/=R.a;
    160.     L.n/=R.n;
    161.     L.f/=R.f;
    162.     return L;
    163. }
    164. //赋值运算%=
    165. Good &operator%=(Good &L,const Good &R)
    166. {
    167.     L.a%=R.a;
    168.     L.n%=R.n;
    169.     L.f%=R.f;
    170.     return L;
    171. }
    172.  
    173. int main()
    174. {
    175.     cout << "-----0-----" << endl;
    176.     Good s0(1,2,3);
    177.     s0.show();
    178.     cout << "-----1-----" << endl;
    179.     Good s1(3,2,1);
    180.     s1.show();
    181.     cout << "----2.0----" << endl;
    182.     Good s2=s0+s1;
    183.     s2.show();
    184.     cout << "----2.1----" << endl;
    185.     s2+=s1;
    186.     s2.show();
    187.     cout << "s2>s1?" << endl;
    188.     bool outcome=s2>s1;
    189.     cout << outcome << endl;
    190.     return 0;
    191. }

    类内函数实现：

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class Good
    6. {
    7. private:
    8.     int n;
    9.     int f;
    10.     int a;
    11. public:
    12.     Good(){}
    13.     Good(int n,int f,int a):n(n),f(f),a(a){}
    14.     void show() const
    15.     {
    16.         cout << "n:" << n << endl;
    17.         cout << "f:" << f << endl;
    18.         cout << "a:" << a << endl;
    19.     }
    20.     //成员
    21.     //算数+
    22.     const Good operator+(const Good &p) const
    23.     {
    24.         Good t;
    25.         t.a=a+p.a;
    26.         t.n=n+p.n;
    27.         t.f=f+p.f;
    28.         return t;
    29.     }
    30.     //算数-
    31.     const Good operator-(const Good &p) const
    32.     {
    33.         Good t;
    34.         t.a=a-p.a;
    35.         t.n=n-p.n;
    36.         t.f=f-p.f;
    37.         return t;
    38.     }
    39.     //算数*
    40.     const Good operator*(const Good &p) const
    41.     {
    42.         Good t;
    43.         t.a=a*p.a;
    44.         t.n=n*p.n;
    45.         t.f=f*p.f;
    46.         return t;
    47.     }
    48.     //算数/
    49.     const Good operator/(const Good &p) const
    50.     {
    51.         Good t;
    52.         t.a=a/p.a;
    53.         t.n=n/p.n;
    54.         t.f=f/p.f;
    55.         return t;
    56.     }
    57.     //算数%
    58.     const Good operator%(const Good &p) const
    59.     {
    60.         Good t;
    61.         t.a=a%p.a;
    62.         t.n=n%p.n;
    63.         t.f=f%p.f;
    64.         return t;
    65.     }
    66.     //关系>
    67.     bool operator>(const Good &R) const
    68.     {
    69.         if(a>R.a && n>R.n && f>R.f){
    70.             return true;
    71.         }else{
    72.             return false;
    73.         }
    74.     }
    75.     //关系<
    76.     bool operator<(const Good &R) const
    77.     {
    78.         if(a
    79.             return true;
    80.         }else{
    81.             return false;
    82.         }
    83.     }
    84.     //关系==
    85.     bool operator==(const Good &R) const
    86.     {
    87.         if(a==R.a && n==R.n && f==R.f){
    88.             return true;
    89.         }else{
    90.             return false;
    91.         }
    92.     }
    93.     //关系>=
    94.     bool operator>=(const Good &R) const
    95.     {
    96.         if(a>=R.a && n>=R.n && f>=R.f){
    97.             return true;
    98.         }else{
    99.             return false;
    100.         }
    101.     }
    102.     //关系<=
    103.     bool operator<=(const Good &R) const
    104.     {
    105.         if(a<=R.a && n<=R.n && f<=R.f){
    106.             return true;
    107.         }else{
    108.             return false;
    109.         }
    110.     }
    111.     //赋值+=
    112.     Good &operator+=(const Good &R)
    113.     {
    114.         a+=R.a;
    115.         n+=R.n;
    116.         f+=R.f;
    117.         return *this;
    118.     }
    119.     //赋值=
    120.     Good &operator=(const Good &R)
    121.     {
    122.         a=R.a;
    123.         n=R.n;
    124.         f=R.f;
    125.         return *this;
    126.     }
    127.     //赋值-=
    128.     Good &operator-=(const Good &R)
    129.     {
    130.         a-=R.a;
    131.         n-=R.n;
    132.         f-=R.f;
    133.         return *this;
    134.     }
    135.     //赋值%=
    136.     Good &operator%=(const Good &R)
    137.     {
    138.         a%=R.a;
    139.         n%=R.n;
    140.         f%=R.f;
    141.         return *this;
    142.     }
    143.     //赋值/=
    144.     Good &operator/=(const Good &R)
    145.     {
    146.         a/=R.a;
    147.         n/=R.n;
    148.         f/=R.f;
    149.         return *this;
    150.     }
    151.     //赋值*=
    152.     Good &operator*=(const Good &R)
    153.     {
    154.         a*=R.a;
    155.         n*=R.n;
    156.         f*=R.f;
    157.         return *this;
    158.     }
    159. };
    160.  
    161. int main()
    162. {
    163.     cout << "-----0-----" << endl;
    164.     Good s0(1,2,3);
    165.     s0.show();
    166.     cout << "-----1-----" << endl;
    167.     Good s1(3,2,1);
    168.     s1.show();
    169.     cout << "----2.0----" << endl;
    170.     Good s2=s0+s1;
    171.     s2.show();
    172.     cout << "----2.1----" << endl;
    173.     s2+=s1;
    174.     s2.show();
    175.     cout << "s2>s1?" << endl;
    176.     bool outcome=s2>s1;
    177.     cout << outcome << endl;
    178.     return 0;
    179. }

  • 相关阅读:
    docker-compose 部署rabbitmq 15672打不开
    C# 使用 RSA 加密算法生成证书签名产生“The system cannot find the file specified”异常
    Linux学习记录——이십팔 网络基础（1）
    在Mac上使用安卓桌面模式
    9.14-广读最新研究方向论文核心思路汇总
    数据库顶会 VLDB 2023 论文解读：字节跳动如何解决超大规模流式任务运维难题
    基于springboot的高校失物招领系统毕业设计源码111731
    Windows系统搭建VisualSVN服务并结合内网穿透实现公网访问
    群晖-使用docker套件部署Prometheus+Grafana
    Scrapy + selenium + 超级鹰验证码识别爬取网站
  • 原文地址：https://blog.csdn.net/m0_61834469/article/details/133754410