• C++学习：类的使用--运算符重载

    我们知道C++可以对函数进行重载，让同名的函数来完成相同的基本操作。其实运算符也是可以重载的，而且有的运算符已经在使用了，就像*，既可以用于地址，又可以用于乘法。

    运算符重载需要使用关键字operator

    语法如下

    1. Type operator Sign(const Type p1, const Type p2)
    2. {
    3.     Type ret;
    4.     
    5.     return ret;
    6. }

     Sign指的是+   -    *   /  等操作符

    复数类开发

    如果我们需要计算两个复数的运算，就需要进行操作符重载了，因为常规的+ -不能直接进行复数运算。

    1. #ifndef COMPLEX_H
    2. #define COMPLEX_H
    3.  
    4.  
    5. class Complex
    6. {
    7. private:
    8.     int a;
    9.     int b;
    10. public:
    11.     Complex();
    12.     Complex(int a, int b);
    13.  
    14.     int getA();
    15.     int getB();
    16.  
    17.     friend Complex operator+ (const Complex& p1, const Complex& p2);
    18. };
    19.  
    20. Complex operator+ (const Complex& p1, const Complex& p2);
    21.  
    22. #endif // COMPLEX_H
    1. #include "complex.h"
    2.  
    3. Complex::Complex(int a, int b)
    4. {
    5.     this->a = a;
    6.     this->b = b;
    7. }
    8.  
    9. Complex::Complex()
    10. {
    11.     a = 0;
    12.     b = 0;
    13. }
    14.  
    15.  
    16.  
    17. int Complex::getA()
    18. {
    19.     return a;
    20. }
    21.  
    22.  
    23. int Complex::getB()
    24. {
    25.     return b;
    26. }
    27.  
    28.  
    29. //+操作符重载，两个复数相加，实部与实部相加，虚部与虚部相加
    30. //operator+相当于函数名，
    31. //但是使用的时候直接使用+就可以
    32. Complex operator+(const Complex& p1, const Complex& p2)
    33. {
    34.     Complex ret;
    35.  
    36.     ret.a = p1.a + p2.a;
    37.     ret.b = p1.b + p2.b;
    38.  
    39.     return ret;
    40.  
    41. }

     

    1. #include 
    2. #include "complex.h"
    3. using namespace std;
    4.  
    5.  
    6. int main()
    7. {
    8.     Complex c1(1, 2);
    9.     Complex c2(3, 4);
    10.  
    11.     //Complex c3 = operator+(c1,c2);
    12.     Complex c3 = c1+c2; //与上面的语句等效
    13.  
    14.     cout <<" c3.getA():"<< c3.getA() << endl;
    15.     cout <<" c3.getB():"<< c3.getB() << endl;
    16.  
    17.     return 0;
    18. }

     分析：语句Complex c3 = operator+(c1,c2); 和语句Complex c3 = c1+c2;效果是一样的，本来复数是不能直接加减的，但是进行了+ 操作符重载，在进行复数运算是编译器法相不能直接+，就去看你有没有炒作符重载，有的话就直接拿来用。

    上面的代码用的友元，在C++中友元是要慎用的，，可以将操作符重载函数直接定义为类的成员函数也是可以运行的，如下所示：

    1. #ifndef COMPLEX_H
    2. #define COMPLEX_H
    3.  
    4.  
    5. class Complex
    6. {
    7. private:
    8.     int a;
    9.     int b;
    10. public:
    11.     Complex();
    12.     Complex(int a, int b);
    13.  
    14.     int getA();
    15.     int getB();
    16.  
    17.     Complex operator+(const Complex& p);
    18. };
    19.  
    20.  
    21. #endif // COMPLEX_H
    1. #include "complex.h"
    2.  
    3. Complex::Complex(int a, int b)
    4. {
    5.     this->a = a;
    6.     this->b = b;
    7. }
    8.  
    9. Complex::Complex()
    10. {
    11.     a = 0;
    12.     b = 0;
    13. }
    14.  
    15.  
    16.  
    17. int Complex::getA()
    18. {
    19.     return a;
    20. }
    21.  
    22.  
    23. int Complex::getB()
    24. {
    25.     return b;
    26. }
    27.  
    28.  
    29. //+操作符重载，两个复数相加，实部与实部相加，虚部与虚部相加
    30. //operator+相当于函数名，
    31. //但是使用的时候直接使用+就可以
    32. Complex Complex::operator+(const Complex& p)
    33. {
    34.     Complex ret;
    35.  
    36.     ret.a = this->a + p.a;
    37.     //等效于ret.a = a + p.a;
    38.  
    39.     ret.b = this->b + p.b;
    40.     //等效于ret.b = b + p.b;
    41.  
    42.     return ret;
    43.  
    44. }

    友元函数与操作符重载函数对比

    友元函数：friend Complex operator+ (const Complex& p1, const Complex& p2);

    使用友源函数，需要左操作数p1和右操作数p2

    类操作符重载函数：Complex operator+(const Complex& p);

    使用类内部操作符重载函数，参数只有一个p,作为右操作数，左操作数就是本身this。

    时间类开发

    下面一个时间类，也进行时间的相关运算，时与时相加减，分钟与分钟相加减

    1. #ifndef MYTIME_H
    2. #define MYTIME_H
    3.  
    4. #include 
    5.  
    6. using namespace  std;
    7.  
    8. class Time
    9. {
    10. private:
    11.     int hours;
    12.     int minutes;
    13.  
    14. public:
    15.     Time();
    16.     Time(int h, int m = 0);
    17.     void AddMin(int m);
    18.     void AddHr(int h);
    19.     void Reset(int h = 0, int m = 0);
    20.     Time Sum(const Time& t) const;
    21.     void Show() const;
    22. };
    23.  
    24. #endif // MYTIME_H

    1. #include "mytime.h"
    2.  
    3.  
    4. Time::Time()
    5. {
    6.     hours = minutes = 0;
    7. }
    8.  
    9. Time::Time(int h, int m)
    10. {
    11.     hours = h;
    12.     minutes = m;
    13. }
    14.  
    15. void Time::AddMin(int m)
    16. {
    17.     minutes += m;
    18.     hours += minutes/60;
    19.     minutes %= 60;
    20. }
    21.  
    22. void Time::AddHr(int h)
    23. {
    24.     hours += h;
    25. }
    26.  
    27. void Time::Reset(int h, int m)
    28. {
    29.     hours = h;
    30.     minutes = m;
    31. }
    32.  
    33. Time Time::Sum(const Time &t) const
    34. {
    35.     Time sum;
    36.     sum.minutes = minutes + t.minutes;
    37.     sum.hours = hours + t.hours + sum.minutes/60;
    38.     sum.minutes %= 60;
    39.  
    40.     return sum;
    41. }
    42.  
    43. void Time::Show() const
    44. {
    45.     cout << hours << " hours, " << minutes << " minutes.\n";
    46. }

    1. #include 
    2. #include "mytime.h"
    3.  
    4. using namespace std;
    5.  
    6. int main()
    7. {
    8.     Time planning;
    9.     Time coding(2, 40);
    10.     Time fixing(5, 55);
    11.     Time total;
    12.  
    13.     cout << "planning time = ";
    14.     planning.Show();
    15.     cout << endl;
    16.  
    17.     cout << "coding time = ";
    18.     coding.Show();
    19.     cout << endl;
    20.  
    21.     cout << "fixing time = ";
    22.     fixing.Show();
    23.     cout << endl;
    24.  
    25.     total = coding.Sum(fixing);
    26.     cout << "coding.Sum(fixing) = ";
    27.     total.Show();
    28.     cout << endl;
    29.  
    30.     return 0;
    31. }

    输出结果

    1. planning time = 0 hours, 0 minutes.
    2.  
    3. coding time = 2 hours, 40 minutes.
    4.  
    5. fixing time = 5 hours, 55 minutes.
    6.  
    7. coding.Sum(fixing) = 8 hours, 35 minutes.

    添加加法运算符

    将Time类转换为重载的加法运算法很容易，只要将Sum()的名称改为operator +()即可。只要把运算符+放在operator的后面

    1. #ifndef STOCK_H
    2. #define STOCK_H
    3. #include 
    4.  
    5. using namespace std;
    6.  
    7. class stock
    8. {
    9. private:
    10.     string company;
    11.     long shares;
    12.     double share_val;
    13.     double total_val;
    14.     void set_tot() {total_val = shares * share_val;}
    15.  
    16. public:
    17.     void buy(long num, double price);
    18.     void sell(long num, double price);
    19.     void update(double price);
    20.     void show() const;
    21.     Time operator+(const Time& t) const;
    22.     const stock& topval(const stock& s) const;
    23.  
    24.     stock(const string& co, long n, double pr);
    25.     stock();
    26.     ~stock();
    27. };
    28.  
    29. #endif // STOCK_H

    1. #include "mytime.h"
    2.  
    3.  
    4. Time::Time()
    5. {
    6.     hours = minutes = 0;
    7. }
    8.  
    9. Time::Time(int h, int m)
    10. {
    11.     hours = h;
    12.     minutes = m;
    13. }
    14.  
    15. void Time::AddMin(int m)
    16. {
    17.     minutes += m;
    18.     hours += minutes/60;
    19.     minutes %= 60;
    20. }
    21.  
    22. void Time::AddHr(int h)
    23. {
    24.     hours += h;
    25. }
    26.  
    27. void Time::Reset(int h, int m)
    28. {
    29.     hours = h;
    30.     minutes = m;
    31. }
    32.  
    33. //运算符+重载
    34. Time Time::operator+(const Time &t) const
    35. {
    36.     Time sum;
    37.     sum.minutes = minutes + t.minutes;
    38.     sum.hours = hours + t.hours + sum.minutes/60;
    39.     sum.minutes %= 60;
    40.  
    41.     return sum;
    42. }
    43.  
    44. void Time::Show() const
    45. {
    46.     cout << hours << " hours, " << minutes << " minutes.\n";
    47. }
    operator+(const Time &t) const与Sum(const Time &t) const效果完全一样，可以理解operator+()就是一个函数，也可以被调用。就像下面的语句一样。
    total = coding.operator+(fixing);

    但是可以进一步简化

    total = coding + fixing;

     这两种方法都讲使用operator+()函数，运算符左侧的coding是调用对象，右边的fixing是参数被传递的对象。

    1. #include 
    2. #include "mytime.h"
    3.  
    4. using namespace std;
    5.  
    6. int main()
    7. {
    8.     Time planning;
    9.     Time coding(2, 40);
    10.     Time fixing(5, 55);
    11.     Time total;
    12.  
    13.     cout << "planning time = ";
    14.     planning.Show();
    15.     cout << endl;
    16.  
    17.     cout << "coding time = ";
    18.     coding.Show();
    19.     cout << endl;
    20.  
    21.     cout << "fixing time = ";
    22.     fixing.Show();
    23.     cout << endl;
    24.  
    25.  
    26.     //total = coding.operator+(fixing);
    27.     total = coding + fixing;
    28.     cout << "coding.Sum(fixing) = ";
    29.     total.Show();
    30.     cout << endl;
    31.  
    32.     return 0;
    33. }

    输出结果没有变化

    1. planning time = 0 hours, 0 minutes.
    2.  
    3. coding time = 2 hours, 40 minutes.
    4.  
    5. fixing time = 5 hours, 55 minutes.
    6.  
    7. coding.Sum(fixing) = 8 hours, 35 minutes.

     运算符重载的限制：

    1、重载后的运算符必须至少有一个操作数是用户定义的类型；

    2、使用运算符使不能违反运算符原来的句法规则；

    3、不能创建新的运算符；

    4、有些运算符不能被重载：如sizeof, ?:, ::等

    5、大多数运算符都可以通过成员或者非成员函数进行重载，但=、（）、[]、->只能通过成员函数进行重载。

    + 、-、 *重载的应用

    1. #ifndef MYTIME_H
    2. #define MYTIME_H
    3.  
    4. #include 
    5.  
    6. using namespace  std;
    7.  
    8. class Time
    9. {
    10. private:
    11.     int hours;
    12.     int minutes;
    13.  
    14. public:
    15.     Time();
    16.     Time(int h, int m = 0);
    17.     void AddMin(int m);
    18.     void AddHr(int h);
    19.     void Reset(int h = 0, int m = 0);
    20.     Time operator+(const Time& t) const;
    21.     Time operator-(const Time& t) const;
    22.     Time operator*(double mult) const;
    23.     void Show() const;
    24. };
    25.  
    26. #endif // MYTIME_H
    1. #include "mytime.h"
    2.  
    3.  
    4. Time::Time()
    5. {
    6.     hours = minutes = 0;
    7. }
    8.  
    9. Time::Time(int h, int m)
    10. {
    11.     hours = h;
    12.     minutes = m;
    13. }
    14.  
    15. void Time::AddMin(int m)
    16. {
    17.     minutes += m;
    18.     hours += minutes/60;
    19.     minutes %= 60;
    20. }
    21.  
    22. void Time::AddHr(int h)
    23. {
    24.     hours += h;
    25. }
    26.  
    27. void Time::Reset(int h, int m)
    28. {
    29.     hours = h;
    30.     minutes = m;
    31. }
    32.  
    33. //运算符+重载
    34. Time Time::operator+(const Time &t) const
    35. {
    36.     Time sum;
    37.     sum.minutes = minutes + t.minutes;
    38.     sum.hours = hours + t.hours + sum.minutes/60;
    39.     sum.minutes %= 60;
    40.  
    41.     return sum;
    42. }
    43.  
    44. Time Time::operator-(const Time& t) const
    45. {
    46.     Time diff;
    47.     int tot1, tot2;
    48.     tot1 = t.minutes + 60 * t.hours;
    49.     tot2 = minutes + 60 * hours;
    50.     diff.minutes = (tot2 - tot1) % 60;
    51.     diff.hours = (tot2 - tot1) / 60;
    52.  
    53.     return diff;
    54. }
    55.  
    56.  
    57. Time Time::operator*(double mult) const
    58. {
    59.     Time result;
    60.     long totalminutes = hours * mult *60 + minutes * mult;
    61.  
    62.     result.hours = totalminutes / 60;
    63.     result.minutes = totalminutes % 60;
    64.  
    65.     return result;
    66. }
    67.  
    68. void Time::Show() const
    69. {
    70.     cout << hours << " hours, " << minutes << " minutes.\n";
    71. }
    1. #include 
    2. #include "mytime.h"
    3.  
    4. using namespace std;
    5.  
    6. int main()
    7. {
    8.     Time weeding(4, 35);
    9.     Time waxing(2, 47);
    10.  
    11.     Time total;
    12.     Time diff;
    13.     Time adjusted;
    14.  
    15.     cout << "weeding time =  ";
    16.     weeding.Show();
    17.     cout << endl;
    18.  
    19.     cout << "waxing time =  ";
    20.     waxing.Show();
    21.     cout << endl;
    22.  
    23.     cout << "total working time =  ";
    24.     total = weeding + waxing;
    25.     total.Show();
    26.     cout << endl;
    27.  
    28.     diff = weeding - waxing;
    29.     cout << "weeding time - waxing time = ";
    30.     diff.Show();
    31.     cout << endl;
    32.  
    33.     adjusted = total * 1.5;
    34.     cout << "adjusted work time = ";
    35.     adjusted.Show();
    36.     cout << endl;
    37.  
    38.     return 0;
    39. }

    输出结果

    1. weeding time =  4 hours, 35 minutes.
    2.  
    3. waxing time =  2 hours, 47 minutes.
    4.  
    5. total working time =  7 hours, 22 minutes.
    6.  
    7. weeding time - waxing time = 1 hours, 48 minutes.
    8.  
    9. adjusted work time = 11 hours, 3 minutes.

  • 相关阅读:
    Bug战场：C++篇
    双节履带机械臂小车实现蓝牙遥控功能
    最新，Spring Boot 2.3.5 发布，你跟上了吗？
    javaO2O生鲜果蔬电商设计与实现计算机毕业设计MyBatis+系统+LW文档+源码+调试部署
    golang 装饰器模式详解
    秋日渲染季 | 效果图充值新升级！金秋好礼等你领
    Arduino基础入门
    VMware下的ubuntu虚拟机，实现虚拟机与本地硬盘间的文件互传
    High-variance latent spaces
    Redis --- 安装教程
  • 原文地址：https://blog.csdn.net/m0_49968063/article/details/133985686