• C++&QT-day4

    1. #include  //运算符重载
    2. using namespace std;
    3.  
    4. class Person
    5. {
    6. //    //全局函数实现+运算符重载
    7. //    friend const Person operator+(const Person &L,const Person &R);
    8. //    //全局函数实现-运算符重载
    9. //    friend const Person operator-(const Person &L,const Person &R);
    10. //    //全局函数实现*运算符重载
    11. //    friend const Person operator*(const Person &L,const Person &R);
    12. //    //全局函数实现/运算符重载
    13. //    friend const Person operator/(const Person &L,const Person &R);
    14. //    //全局函数实现%运算符重载
    15. //    friend const Person operator%(const Person &L,const Person &R);
    16.  
    17. //    //全局函数实现>运算符重载
    18. //    friend bool operator>(const Person &L, const Person &R);
    19. //    //全局函数实现>=运算符重载
    20. //    friend bool operator>=(const Person &L, const Person &R);
    21. //    //全局函数实现<运算符重载
    22. //    friend bool operator<(const Person &L, const Person &R);
    23. //    //全局函数实现<=运算符重载
    24. //    friend bool operator<=(const Person &L, const Person &R);
    25. //    //全局函数实现==运算符重载
    26. //    friend bool operator==(const Person &L, const Person &R);
    27. //    //全局函数实现!=运算符重载
    28. //    friend bool operator!=(const Person &L, const Person &R);
    29.  
    30.  
    31. //    //全局函数实现=运算符重载
    32. //    friend Person &operator=(Person &L, const Person &R);
    33. //    //全局函数实现+=运算符重载
    34. //    friend Person &operator+=(Person &L, const Person &R);
    35. //    //全局函数实现-=运算符重载
    36. //    friend Person &operator-=(Person &L, const Person &R);
    37. //    //全局函数实现*=运算符重载
    38. //    friend Person &operator*=(Person &L, const Person &R);
    39. //    //全局函数实现/=运算符重载
    40. //    friend Person &operator/=(Person &L, const Person &R);
    41. //    //全局函数实现%=运算符重载
    42. //    friend Person &operator%=(Person &L, const Person &R);
    43.  
    44. private:
    45.     int a;
    46.     int b;
    47. public:
    48.     Person(){}
    49.     Person(int a, int b):a(a),b(b){}
    50. /****************成员函数实现+运算符重载*******************/
    51.     const Person operator+(const Person &p)const
    52.     {
    53.         Person temp;
    54.         temp.a = a + p.a;
    55.         temp.b = b + p.b;
    56.         return  temp;
    57.     }
    58.     /****************成员函数实现-运算符重载*******************/
    59.     const Person operator-(const Person &p)const
    60.     {
    61.         Person temp;
    62.         temp.a = a - p.a;
    63.         temp.b = b - p.b;
    64.         return  temp;
    65.     }
    66.     /****************成员函数实现*运算符重载*******************/
    67.     const Person operator*(const Person &p)const
    68.     {
    69.         Person temp;
    70.         temp.a = a * p.a;
    71.         temp.b = b * p.b;
    72.         return  temp;
    73.     }
    74.     /****************成员函数实现/运算符重载*******************/
    75.     const Person operator/(const Person &p)const
    76.     {
    77.         Person temp;
    78.         if(0==p.a && 0==p.b)
    79.             cout << "除数为0" << endl;
    80.         else if(0==p.a && 0!=p.b)
    81.         {
    82.             cout << "a除数为0" << "  b = " << b << endl;
    83.             temp.a = a / p.b;
    84.         }
    85.         else if(0!=p.a && 0==p.b)
    86.         {
    87.             temp.b = b / p.a;
    88.             cout << "a = " << a << " b除数为0" << endl;
    89.         }
    90.         else
    91.         {
    92.             temp.b = b / p.a;
    93.             temp.a = a / p.b;
    94.             cout << "a = " << a << "  b = " << b << endl;
    95.         }
    96.         return  temp;
    97.     }
    98.     /****************成员函数实现%运算符重载*******************/
    99.     const Person operator%(const Person &p)const
    100.     {
    101.         Person temp;
    102.         temp.a = a % p.a;
    103.         temp.b = b % p.b;
    104.         return  temp;
    105.     }
    106. /***************成员函数实现>关系运算符重载***************/
    107.     bool operator>(const Person &R)const
    108.     {
    109.         if(a>R.a && b>R.b)
    110.         {
    111.             return true;
    112.         }
    113.         else
    114.         {
    115.             return false;
    116.         }
    117.     }
    118.     /***************成员函数实现>=关系运算符重载***************/
    119.     bool operator>=(const Person &R)const
    120.     {
    121.         if(a>=R.a && b>=R.b)
    122.         {
    123.             return true;
    124.         }
    125.         else
    126.         {
    127.             return false;
    128.         }
    129.     }
    130.     /***************成员函数实现<关系运算符重载***************/
    131.     bool operator<(const Person &R)const
    132.     {
    133.         if(a
    134.         {
    135.             return true;
    136.         }
    137.         else
    138.         {
    139.             return false;
    140.         }
    141.     }
    142.     /***************成员函数实现<=关系运算符重载***************/
    143.     bool operator<=(const Person &R)const
    144.     {
    145.         if(a<=R.a && b<=R.b)
    146.         {
    147.             return true;
    148.         }
    149.         else
    150.         {
    151.             return false;
    152.         }
    153.     }
    154.     /***************成员函数实现==关系运算符重载***************/
    155.     bool operator==(const Person &R)const
    156.     {
    157.         if(a==R.a && b==R.b)
    158.         {
    159.             return true;
    160.         }
    161.         else
    162.         {
    163.             return false;
    164.         }
    165.     }
    166.     /***************成员函数实现!=关系运算符重载***************/
    167.     bool operator!=(const Person &R)const
    168.     {
    169.         if(a!=R.a && b!=R.b)
    170.         {
    171.             return true;
    172.         }
    173.         else
    174.         {
    175.             return false;
    176.         }
    177.     }
    178. /***************成员函数实现=赋值运算符重载***************/
    179.     Person &operator=(const Person &R)
    180.     {
    181.         a = R.a;
    182.         b = R.b;
    183.         return *this;
    184.     }
    185.     /***************成员函数实现+=赋值运算符重载***************/
    186.     Person &operator+=(const Person &R)
    187.     {
    188.         a += R.a;
    189.         b += R.b;
    190.         return *this;
    191.     }
    192.     /***************成员函数实现-=赋值运算符重载***************/
    193.     Person &operator-=(const Person &R)
    194.     {
    195.         a -= R.a;
    196.         b -= R.b;
    197.         return *this;
    198.     }
    199.     /***************成员函数实现*=赋值运算符重载***************/
    200.     Person &operator*=(const Person &R)
    201.     {
    202.         a *= R.a;
    203.         b *= R.b;
    204.         return *this;
    205.     }
    206.     /***************成员函数实现/=赋值运算符重载***************/
    207.     Person &operator/=(const Person &R)
    208.     {
    209.         if(0==R.a && 0==R.b)
    210.             cout << "除数为0" << endl;
    211.         else if(0==R.a && 0!=R.b)
    212.         {
    213.             cout << "a除数为0" << "  b = " << b << endl;
    214.             a = a / R.b;
    215.         }
    216.         else if(0!=R.a && 0==R.b)
    217.         {
    218.             b = b / R.a;
    219.             cout << "a = " << a << " b除数为0" << endl;
    220.         }
    221.         else if(0!=R.a && 0!=R.b)
    222.         {
    223.             a = a / R.a;
    224.             b = b / R.b;
    225.             cout << "a = " << a << "  b = " << b << endl;
    226.         }
    227.         return *this;
    228.     }
    229.     /***************成员函数实现%=赋值运算符重载***************/
    230.     Person &operator%=(const Person &R)
    231.     {
    232.         a %= R.a;
    233.         b %= R.b;
    234.         return *this;
    235.     }
    236.  
    237.     void show()
    238.     {
    239.         cout << "a = " << a << "  b = " << b << endl;
    240.     }
    241.  
    242. };
    243.  
    244. ///****************全局函数实现+运算符重载*******************/
    245. //const Person operator+(const Person &L,const Person &R)
    246. //{
    247. //    Person temp;
    248. //    temp.a = L.a + R.a;
    249. //    temp.b = L.b + R.b;
    250. //    return  temp;
    251. //}
    252. ///****************全局函数实现-运算符重载*******************/
    253. //const Person operator-(const Person &L,const Person &R)
    254. //{
    255. //    Person temp;
    256. //    temp.a = L.a - R.a;
    257. //    temp.b = L.b - R.b;
    258. //    return  temp;
    259. //}
    260. ///****************全局函数实现*运算符重载*******************/
    261. //const Person operator*(const Person &L,const Person &R)
    262. //{
    263. //    Person temp;
    264. //    temp.a = L.a * R.a;
    265. //    temp.b = L.b * R.b;
    266. //    return  temp;
    267. //}
    268. ///****************全局函数实现/运算符重载*******************/
    269. //const Person operator/(const Person &L,const Person &R)
    270. //{
    271. //    Person temp;
    272. //    if(0==R.a && 0==R.b)
    273. //        cout << "除数为0" << endl;
    274. //    else if(0==R.a && 0!=R.b)
    275. //    {
    276. //        cout << "a除数为0" << "  b = " << L.b << endl;
    277. //        temp.a = L.a / R.b;
    278. //    }
    279. //    else if(0!=R.a && 0==R.b)
    280. //    {
    281. //        temp.b = L.b / R.a;
    282. //        cout << "a = " << L.a << " b除数为0" << endl;
    283. //    }
    284. //    else if(0!=R.a && 0!=R.b)
    285. //    {
    286. //        temp.b = L.b / R.a;
    287. //        temp.a = L.a / R.b;
    288. //        cout << "a = " << L.a << "  b = " << L.b << endl;
    289. //    }
    290. //    return  temp;
    291. //}
    292. ///****************全局函数实现%运算符重载*******************/
    293. //const Person operator%(const Person &L,const Person &R)
    294. //{
    295. //    Person temp;
    296. //    temp.a = L.a % R.a;
    297. //    temp.b = L.b % R.b;
    298. //    return  temp;
    299. //}
    300.  
    301. ///***************全局函数实现>关系运算符重载***************/
    302. //bool operator>(const Person &L, const Person &R)
    303. //{
    304. //    if(L.a>R.a && L.b>R.b)
    305. //    {
    306. //        return true;
    307. //    }
    308. //    else
    309. //    {
    310. //        return false;
    311. //    }
    312. //}
    313. ///***************全局函数实现>=关系运算符重载***************/
    314. //bool operator>=(const Person &L, const Person &R)
    315. //{
    316. //    if(L.a>=R.a && L.b>=R.b)
    317. //    {
    318. //        return true;
    319. //    }
    320. //    else
    321. //    {
    322. //        return false;
    323. //    }
    324. //}
    325. ///***************全局函数实现<关系运算符重载***************/
    326. //bool operator<(const Person &L, const Person &R)
    327. //{
    328. //    if(L.a
    329. //    {
    330. //        return true;
    331. //    }
    332. //    else
    333. //    {
    334. //        return false;
    335. //    }
    336. //}
    337. ///***************全局函数实现>关系运算符重载***************/
    338. //bool operator<=(const Person &L, const Person &R)
    339. //{
    340. //    if(L.a<=R.a && L.b<=R.b)
    341. //    {
    342. //        return true;
    343. //    }
    344. //    else
    345. //    {
    346. //        return false;
    347. //    }
    348. //}
    349. ///***************全局函数实现==关系运算符重载***************/
    350. //bool operator==(const Person &L, const Person &R)
    351. //{
    352. //    if(L.a==R.a && L.b==R.b)
    353. //    {
    354. //        return true;
    355. //    }
    356. //    else
    357. //    {
    358. //        return false;
    359. //    }
    360. //}
    361. ///***************全局函数实现!=关系运算符重载***************/
    362. //bool operator!=(const Person &L, const Person &R)
    363. //{
    364. //    if(L.a!=R.a && L.b!=R.b)
    365. //    {
    366. //        return true;
    367. //    }
    368. //    else
    369. //    {
    370. //        return false;
    371. //    }
    372. //}
    373.  
    374. ///***************全局函数实现=赋值运算符重载***************/
    375. //Person &operator=(Person &L, const Person &R)
    376. //{
    377. //    L.a = R.a;
    378. //    L.b = R.b;
    379. //    return L;
    380. //}
    381. ///***************全局函数实现+=赋值运算符重载***************/
    382. //Person &operator+=(Person &L, const Person &R)
    383. //{
    384. //    L.a += R.a;
    385. //    L.b += R.b;
    386. //    return L;
    387. //}
    388. ///***************全局函数实现-=赋值运算符重载***************/
    389. //Person &operator-=(Person &L, const Person &R)
    390. //{
    391. //    L.a -= R.a;
    392. //    L.b -= R.b;
    393. //    return L;
    394. //}
    395. ///***************全局函数实现*=赋值运算符重载***************/
    396. //Person &operator*=(Person &L, const Person &R)
    397. //{
    398. //    L.a *= R.a;
    399. //    L.b *= R.b;
    400. //    return L;
    401. //}
    402. ///***************全局函数实现/=赋值运算符重载***************/
    403. //Person &operator/=(Person &L, const Person &R)
    404. //{
    405. //    if(0==R.a && 0==R.b)
    406. //        cout << "除数为0" << endl;
    407. //    else if(0==R.a && 0!=R.b)
    408. //    {
    409. //        cout << "a除数为0" << "  b = " << L.b << endl;
    410. //        L.b /= R.b;
    411. //    }
    412. //    else if(0!=R.a && 0==R.b)
    413. //    {
    414. //        L.a /= R.a;
    415. //        cout << "a = " << L.a << " b除数为0" << endl;
    416. //    }
    417. //    else if(0!=R.a && 0!=R.b)
    418. //    {
    419. //        L.a /= R.a;
    420. //        L.b /= R.b;
    421. //        cout << "a = " << L.a << "  b = " << L.b << endl;
    422. //    }
    423. //    return L;
    424. //}
    425. ///***************全局函数实现%=赋值运算符重载***************/
    426. //Person &operator%=(Person &L, const Person &R)
    427. //{
    428. //    L.a %= R.a;
    429. //    L.b %= R.b;
    430. //    return L;
    431. //}
    432.  
    433. /****************************************************/
    434. int main()
    435. {
    436.     Person p1(3,4);
    437.     Person p2(1,2);
    438.     Person p3 = p1 + p2; p3.show();
    439.     Person p4 = p1 - p2; p4.show();
    440.     Person p5 = p1 * p2; p5.show();
    441.     Person p6 = p1 / p2;
    442.     Person p7 = p1 % p2; p7.show();
    443.  
    444.     if(p3>p2)
    445.         cout << "p3>p2" << endl;
    446.     else if(p3>=p2)
    447.         cout << "p3>=p2" << endl;
    448.     else if(p3
    449.         cout << "p3 << endl;
    450.     else if(p3<=p2)
    451.         cout << "p3<=p2" << endl;
    452.     else if(p3==p2)
    453.         cout << "p3==p2" << endl;
    454.     else if(p3!=p2)
    455.         cout << "p3!=p2" << endl;
    456.  
    457.     p3+=p2;p3.show();
    458.     p3-=p2;p3.show();
    459.     p3*=p2;p3.show();
    460.     p3/=p2;
    461.     p3%=p2;p3.show();
    462.  
    463.     return 0;
    464. }

  • 相关阅读:
    博客从 CloudBase 迁移至云主机
    287. 寻找重复数
    PAT 1040 Longest Symmetric String
    [CVPR2022] A Dual Weighting Label Assignment Scheme for Object Detection
    leetcode：6240. 树上最大得分和路径【两次dfs模拟 + 读题题 + 不要用list做py函数的参数！！】
    基于SNAT+DNAT发布内网K8S及Jenkins+gitlab+Harbor模拟CI/CD的综合项目
    Spring-RabbitMQ 工作队列实践
    2023网安面试题170道，轻松应对面试
    (18)不重启服务动态停止、启动RabbitMQ消费者
    注释之重——程序员与代码可维护性
  • 原文地址：https://blog.csdn.net/qq_53195772/article/details/133755676