• 实验十三 运算符重载2

    A. 时钟调整（运算符前后增量）

    假定一个时钟包含时、分、秒三个属性，取值范围分别为0~11，0~59，0~59，具体要求如下：

    1、用一元运算符++，并且是前增量的方法，实现时钟的调快操作。例如要把时钟调快5秒，则执行5次”  ++<对象> “ 的操作

    2、用一元运算符--，并且是后增量的方法，实现时钟的调慢操作。例如要把时钟调慢10秒，则执行10次” <对象>-- “的操作

    3、用构造函数的方法实现时钟对象的初始化，用输出函数实现时钟信息的输出

    clock和time是系统内部函数，所以不要用来做类名或者其他

    输入

    第一行输入时钟的当前时间时、分、秒

    第二行输入t表示有t个示例

    第三行输入t个整数x，如果x为正整数，则表示执行调快操作，使用重载运算符++；如果x为负整数，则表示执行调慢操作，使用重载运算符--

    每次的调快或调慢操作都是承接上一次调整后的结果进行，例如先调快10秒，再调慢2秒，那么调慢2秒是接着调快10秒后的结果进行的

    输出

    每行输出每个时钟调整操作后的时分秒

    输入样例1 

    11 58 46
    4
    5 70 -22 -55
    输出样例1

    11:58:51
    0:0:1
    11:59:39
    11:58:44

    1. #include <iostream>
    2. using namespace std;
    3. class shizhong
    4. {
    5. private:
    6.     int hour, minute, second;
    7. public:
    8.     shizhong(int h, int m, int s) :hour(h), minute(m), second(s)
    9.     {
    10.  
    11.     }
    12.     friend shizhong operator++(shizhong& s);
    13.     friend shizhong operator--(shizhong& s,int);
    14.     void print()
    15.     {
    16.         cout << hour << ":" << minute << ":" << second << endl;
    17.     }
    18. };
    19. shizhong operator++(shizhong& s)
    20. {
    21.     s.second++;
    22.     if (s.second == 60)
    23.     {
    24.         s.second = 0;
    25.         s.minute++;
    26.         if (s.minute == 60)
    27.         {
    28.             s.minute = 0;
    29.             s.hour++;
    30.             if (s.hour == 12)
    31.             {
    32.                 s.hour = 0;
    33.             }
    34.         }
    35.     }
    36.     return s;
    37. }
    38. shizhong operator--(shizhong&a,int)
    39. {
    40.     shizhong temp = a;
    41.     if (a.second == 0)
    42.     {
    43.         a.second = 59;
    44.         a.minute--;
    45.         if (a.minute == -1)
    46.         {
    47.             a.minute = 59;
    48.             a.hour--;
    49.             if (a.hour == -1)
    50.             {
    51.                 a.hour = 11;
    52.  
    53.             }
    54.         }
    55.  
    56.     }
    57.     else
    58.     {
    59.         a.second--;
    60.     }
    61.     return temp;
    62. }
    63. int main()
    64. {
    65.     int hour, minute, second, x;
    66.     int t;
    67.     cin >> hour >> minute >> second;
    68.     cin >> t;
    69.     shizhong s(hour, minute, second);
    70.     while (t--)
    71.     {
    72.         while (cin >> x)
    73.         {
    74.             if (x > 0)
    75.             {
    76.                 for (int i = 0; i < x; i++)
    77.                 {
    78.                     ++s;
    79.                 }
    80.  
    81.               
    82.             }
    83.             if(x<0)
    84.             {
    85.                 for (int i = 0; i > x; i--)
    86.                 {
    87.                     s--;
    88.                 }    
    89.             }
    90.             s.print();
    91.         }
    92.        
    93.     }
    94. }

    B. 矩阵（运算符重载）

    下面主函数和CMatrix类完成矩阵的输入、输出。请补齐CMatrix类中需要的成员函数。

    注意：主函数和CMatrix类已给代码不可修改，只可在CMatrix类中添加新的成员函数，并补充完整未实现的成员函数。修改已知代码不计分。

    提示：根据已给代码分析CMatrix需要重载哪些运算符？

    输入

     测试次数

    每组测试数据格式如下：

    正整数n、m，分表表示矩阵的行、列

    n*m行整数数据

    输出

    每组测试数据输出矩阵数据两次，具体输出格式见样例。

    输入样例1 

    2
    3 3
    1 2 3
    4 5 6
    7 8 9
    2 4
    10 20 30 40
    50 60 70 80
    输出样例1

    matrixA:
    1 2 3 
    4 5 6 
    7 8 9 
    matrixB:
    1 2 3 
    4 5 6 
    7 8 9 
    matrixA:
    10 20 30 40 
    50 60 70 80 
    matrixB:
    10 20 30 40 
    50 60 70 80 
     

    1. #include <iostream>
    2. using namespace std;
    3. // 定义矩阵类
    4. class CMatrix
    5. {
    6. private:
    7.     int n, m; // n-行，m-列
    8.     int** data; // 存储矩阵数据
    9. public:
    10.     CMatrix()
    11.     {
    12.         n = 0;         //防止运行时异常
    13.         m = 0;
    14.         data = NULL;
    15.     }
    16.     CMatrix(int n1, int m1)
    17.     {
    18.         n = n1;
    19.         m = m1;
    20.         // 分配n行m列的二维数组空间
    21.         data = new int* [n];
    22.         for (int i = 0; i < n; i++)
    23.         {
    24.             data[i] = new int[m];
    25.         }
    26.     }
    27.     ~CMatrix()
    28.     {
    29.         // 释放空间
    30.         for (int i = 0; i < n; i++)
    31.         {
    32.             delete[] data[i];
    33.         }
    34.         delete[] data;
    35.     }
    36.     CMatrix(const CMatrix& a)
    37.     {
    38.         n = a.n;
    39.         m = a.m;
    40.         data = new int* [n];
    41.         for (int i = 0; i < n; i++)
    42.         {
    43.             data[i] = new int[m];
    44.             for (int j = 0; j < m; j++)
    45.             {
    46.                 data[i][j] = a.data[i][j];
    47.             }
    48.         }
    49.     }
    50.     CMatrix& operator = (const CMatrix& a)
    51.     {
    52.         //应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝。
    53.         if (data != NULL)
    54.         {
    55.             for (int i = 0; i < n; i++)
    56.             {
    57.                 delete[] data[i];
    58.  
    59.             }
    60.             delete[] data;
    61.         }
    62.         n = a.n;
    63.         m = a.m;
    64.         //二维数组的深拷贝
    65.         data = new int* [n];
    66.         for (int i = 0; i < n; i++)
    67.         {
    68.             data[i] = new int[m];
    69.         }
    70.  
    71.         for (int i = 0; i < n; i++)
    72.         {
    73.             for (int j = 0; j < m; j++)
    74.             {
    75.                 data[i][j] = a.data[i][j];
    76.             }
    77.         }
    78.         return *this;
    79.     }
    80.  
    81.     int* const operator [](const int k)//指针常量是为了输入 
    82.     {
    83.         return data[k];//只用一个[],因为有* 
    84.     }
    85.  
    86.     int operator () (int i, int j)        //输出二维数组
    87.     {
    88.         return data[i][j];
    89.     }
    90. };
    91.  
    92. int main()
    93. {
    94.     int t, n, m, i, j;
    95.     cin >> t;
    96.     while (t--)
    97.     {
    98.         cin >> n >> m;
    99.         // 定义矩阵对象matrixA
    100.         CMatrix matrixA(n, m);
    101.         for (i = 0; i < n; i++)
    102.         {
    103.             for (j = 0; j < m; j++)
    104.             {
    105.                 // 输入第i行第j列的数据
    106.                 cin >> matrixA[i][j];//这里用到了[]重载 
    107.             }
    108.         }
    109.         // 输出matrixA中的数据
    110.         cout << "matrixA:" << endl;
    111.         for (i = 0; i < n; i++)
    112.         {
    113.             for (j = 0; j < m; j++)
    114.             {
    115.                 cout << matrixA(i, j) << " ";//（）重载
    116.             }
    117.             cout << endl;
    118.         }
    119.         // 定义矩阵对象matrixB
    120.         CMatrix matrixB;
    121.         matrixB = matrixA;
    122.         // 输出marixB中的数据
    123.         cout << "matrixB:" << endl;
    124.         for (i = 0; i < n; i++)
    125.         {
    126.             for (j = 0; j < m; j++)
    127.             {
    128.                 cout << matrixB[i][j] << " ";
    129.             }
    130.             cout << endl;
    131.         }
    132.     }
    133.     return 0;
    134. }

    D. 货币加减（运算符重载）

    题目描述

    定义CMoney类，包含元、角、分三个数据成员，友元函数重载‘+’、'-'，实现货币的加减运算（假设a-b中a的金额始终大于等于b的金额），

    重载输入及输出，实现货币的输入，输出。

    读入最初的货币值，对其不断进行加、减操作，输出结果。

    可根据需要，为CMoney类添加构造函数或其它成员函数。

    输入

    测试次数

    每组测试数据格式如下：

    第一行，初始货币：元 角 分

    第二行开始，每行一个操作：add 元 角 分（加）、minus 元 角 分（减）、stop（结束）

    输出

     对每组测试数据，输出操作终止后的货币金额，具体输出格式见样例。

    输入样例1 

    2
    0 0 0
    add 48 9 0
    minus 0 5 3
    add 18 6 8
    add 12 1 2
    stop
    10 2 5
    add 5 8 0
    add 32 1 2
    minus 10 5 9
    minus 37 5 8
    stop


    输出样例1

    79元1角7分
    0元0角0分
     

    1. #include<iostream>
    2. using namespace std;
    3. class Cmoney
    4. {
    5. private:
    6.     int yuan, fen, jiao;
    7. public:
    8.     friend Cmoney operator+(Cmoney&, Cmoney&);
    9.     friend Cmoney operator-(Cmoney&, Cmoney&);
    10.     friend istream& operator >> (istream& cin, Cmoney& a);
    11.     friend ostream& operator << (ostream& cout, Cmoney& c);
    12.     void print()
    13.     {
    14.         cout << yuan << "元" << jiao << "角" << fen << "分";
    15.     }
    16.     Cmoney()
    17.     {
    18.         yuan = 0, jiao = 0, fen = 0;
    19.     }
    20.     Cmoney(int y, int j, int f) :yuan(y), jiao(j), fen(f)
    21.     {
    22.  
    23.     }
    24. };
    25. Cmoney operator+(Cmoney& c1, Cmoney& c2)
    26. {
    27.     //由于分不能超过10 角不能超过10 统一换算成分
    28.     Cmoney temp;
    29.     int c1fen = c1.yuan * 100 + c1.jiao * 10 + c1.fen;
    30.     int c2fen = c2.yuan * 100 + c2.jiao * 10 + c2.fen;
    31.     int sum = c1fen + c2fen;
    32.     temp.yuan = sum / 100 ;
    33.     temp.jiao = (sum % 100) / 10;
    34.     temp.fen = (sum % 100) % 10;
    35.     return temp;
    36. }
    37. Cmoney operator-(Cmoney& c1, Cmoney& c2)
    38. {
    39.     Cmoney temp;
    40.     int c1fen = c1.yuan * 100 + c1.jiao * 10 + c1.fen;
    41.     int c2fen = c2.yuan * 100 + c2.jiao * 10 + c2.fen;
    42.     int sum = c1fen - c2fen; //假设c1-c2中的金额始终大于0
    43.     temp.yuan = sum / 100 ;
    44.     temp.jiao = (sum % 100) / 10;
    45.     temp.fen = (sum % 100) % 10;
    46.     return temp;
    47. }
    48. //全局函数 左移 右移运算符
    49. istream& operator >> (istream& cin, Cmoney& a)//istream& 自己命名一个cin
    50. {
    51.     cin >> a.yuan >> a.jiao >> a.fen;
    52.     return cin; //一定要返回自己命名的
    53. }
    54. ostream& operator << (ostream& cout, Cmoney& c)
    55. {
    56.     cout << c.yuan << "元" << c.jiao << "角" << c.fen << "分" << endl;
    57.     return cout;
    58. }
    59. int main()
    60. {
    61.  
    62.     int t;
    63.     cin >> t;
    64.     while (t--)
    65.     {
    66.         int yuan, jiao, fen;
    67.         cin >> yuan >> jiao >> fen;
    68.         Cmoney c1(yuan, jiao, fen);
    69.         string caozuo;
    70.         cin >> caozuo;
    71.         Cmoney c3;
    72.         while (caozuo != "stop")
    73.         {
    74.             if (caozuo == "add")
    75.             {
    76.                 cin >> yuan >> jiao >> fen;
    77.                 Cmoney c2(yuan, jiao, fen);
    78.                 c3 = c1 + c2;
    79.             }
    80.             if (caozuo == "minus")
    81.             {
    82.                 cin >> yuan >> jiao >> fen;
    83.                 Cmoney c2(yuan, jiao, fen);
    84.                 c3 = c1 - c2;
    85.             }
    86.             c1 = c3;   //重置c1为上一个操作后的c3 
    87.             cin >> caozuo;//继续输入操作 直到输入stop退出循环
    88.         }
    89.         cout << c3; //运用了重载运算 <<
    90.     }
    91.  
    92. }

    C. 矩形关系（运算符重载）

    题目描述

    假设坐标采用二维平面坐标。

    定义点类CPoint，包含属性x,y（整型）。方法有：带参构造函数，getX，getY分别返回点的x坐标，y坐标。

    定义矩形类CRectangle，包含属性：矩形的左上角坐标leftPoint，右下角坐标rightPoint。类中方法有：

    1）带参构造函数，初始化矩形的左上角、右下角

    2）重载>运算符，参数为CPoint点对象，假设为p，若p在矩形内，返回true,否则返回false。

    3）重载>运算符，第一个矩形若包含第二个矩形（部分边界可以相等），返回true，否则返回false。（要求该函数调用2）实现）

    4）重载==运算符，判断两个矩形是否一致，返回true或false。

    5）重载*运算符，判断两个矩形是否有重叠部分，返回true或false。

    6）重载类型转换运算符，计算矩形的面积并返回，面积是整型。

    7）重载<<运算符，输出矩形的两个角坐标，具体格式见样例。

    输入2个矩形，计算面积，判断矩形的关系。主函数如下，不可修改。

    输入样例1 

    2
    1 4 4 1
    2 3 3 2
    1 4 4 1
    0 3 5 2
    输出样例1

    矩形1:1 4 4 1 9
    矩形2:2 3 3 2 1
    矩形1包含矩形2

    矩形1:1 4 4 1 9
    矩形2:0 3 5 2 5
    矩形1和矩形2相交

    1. #include<iostream>
    2. using namespace std;
    3. class CPoint
    4. {
    5. private:
    6.     int x, y;
    7. public:
    8.     CPoint(int xx, int yy)
    9.     {
    10.         x = xx; y = yy;
    11.     }
    12.     int getX()
    13.     {
    14.         return x;
    15.     }
    16.     int getY()
    17.     {
    18.         return y;
    19.     }
    20. };
    21.  
    22. class CRectangle
    23. {
    24. private:
    25.     CPoint leftPoint, rightPoint; //左上角坐标 右下角坐标
    26. public:
    27.     CRectangle(int x1, int y1, int x2, int y2) :leftPoint(x1, y1), rightPoint(x2, y2)
    28.     {
    29.  
    30.     }
    31.     //重载>运算符，参数为CPoint点对象，假设为p，若p在矩形内，返回true,否则返回false
    32.     bool operator>(CPoint& p)
    33.     {
    34.         if (p.getX() > leftPoint.getX() && p.getX() < rightPoint.getX() && p.getY() < leftPoint.getY() && p.getY() > rightPoint.getY())
    35.         {
    36.             return true;
    37.         }
    38.         else
    39.         {
    40.             return false;
    41.         }
    42.     }
    43.     //重载>运算符，第一个矩形若包含第二个矩形（部分边界可以相等），返回true，否则返回false  
    44.     bool operator>(CRectangle& cr)    //传入的cr是第二个矩形 两个坐标点都要符合在矩形上（包含边界）
    45.     {
    46.         if (cr.leftPoint.getX() >= leftPoint.getX() &&
    47.             cr.leftPoint.getX() <= rightPoint.getX() &&
    48.             cr.leftPoint.getY() <= leftPoint.getY() && 
    49.             cr.leftPoint.getY() >= rightPoint.getY()  &&  
    50.             cr.rightPoint.getX() >= leftPoint.getX() &&
    51.             cr.rightPoint.getX() <= rightPoint.getX() &&
    52.             cr.rightPoint.getY() <= leftPoint.getY() && 
    53.             cr.rightPoint.getY() >= rightPoint.getY()      )
    54.         {
    55.             return true;
    56.         }
    57.         else
    58.         {
    59.             return false;
    60.         }
    61.     }
    62.     //重载==运算符，判断两个矩形是否一致
    63.     bool operator==(CRectangle& cr)      //两个坐标点一致
    64.     {
    65.         if (cr.leftPoint.getX() == leftPoint.getX()&&
    66.             cr.leftPoint.getY() == leftPoint.getY() && 
    67.             cr.rightPoint.getX() == rightPoint.getX() && 
    68.             cr.rightPoint.getY() == rightPoint.getY())
    69.         {
    70.             return true;
    71.         }
    72.         else
    73.         {
    74.             return false;
    75.         }
    76.     }
    77.     //重载*运算符，判断两个矩形是否有重叠部分，返回true或false。
    78.     bool operator*(CRectangle& cr)
    79.     {     //不重叠的情况
    80.         if (cr.leftPoint.getX() > rightPoint.getX() 
    81.             || cr.leftPoint.getY() < rightPoint.getY() || 
    82.             cr.rightPoint.getX() < leftPoint.getX() || 
    83.             cr.rightPoint.getY() > leftPoint.getY())
    84.         {
    85.             return false;
    86.         }
    87.         else
    88.         {
    89.             return true;
    90.         }
    91.     }
    92.     //重载类型转换运算符，计算矩形的面积并返回，面积是整型。
    93.     operator int()
    94.     {
    95.         int area;
    96.         area = (rightPoint.getX() - leftPoint.getX()) * (leftPoint.getY() - rightPoint.getY());
    97.         return area;
    98.     }
    99.     friend ostream& operator<<(ostream& stream, CRectangle& cr);
    100. };
    101. //全局函数 重载<<运算符，输出矩形的两个角坐标
    102. ostream& operator<<(ostream& stream, CRectangle& cr)
    103. {
    104.     stream << cr.leftPoint.getX() << " " << cr.leftPoint.getY() << " " << cr.rightPoint.getX() << " " << cr.rightPoint.getY();
    105.     return stream;
    106. }
    107.  
    108. int main()
    109. {
    110.     int t, x1, x2, y1, y2;
    111.     cin >> t;
    112.     while (t--)
    113.     {
    114.         // 矩形1的左上角、右下角
    115.         cin >> x1 >> y1 >> x2 >> y2;
    116.         CRectangle rect1(x1, y1, x2, y2);
    117.         // 矩形2的左上角、右下角
    118.         cin >> x1 >> y1 >> x2 >> y2;
    119.         CRectangle rect2(x1, y1, x2, y2);
    120.         // 输出矩形1的坐标及面积         //用了<<重载 和 int（）重载
    121.         cout << "矩形1:" << rect1 << " " << (int)rect1 << endl;
    122.         // 输出矩形2的坐标及面积
    123.         cout << "矩形2:" << rect2 << " " << (int)rect2 << endl;
    124.         if (rect1 == rect2)     //==重载
    125.         {
    126.             cout << "矩形1和矩形2相等" << endl;
    127.         }
    128.         else if (rect2 > rect1)    // >重载
    129.         {
    130.             cout << "矩形2包含矩形1" << endl;
    131.         }
    132.         else if (rect1 > rect2)   // >重载
    133.         {
    134.             cout << "矩形1包含矩形2" << endl;
    135.         }
    136.         else if (rect1 * rect2)      //重叠
    137.         {
    138.             cout << "矩形1和矩形2相交" << endl;
    139.         }
    140.         else
    141.         {
    142.             cout << "矩形1和矩形2不相交" << endl;
    143.         }
    144.         cout << endl;
    145.     }
    146.     return 0;
    147. }

  • 相关阅读:
    Vector | Graph：蚂蚁首个开源Graph RAG框架设计解读
    最全总结：聊聊 Python 命令行参数化的几种方式
    servlet 教程 2：返回 jsp 页面
    胞外囊泡代谢组学—前列腺癌代谢变化研究的新策略
    文举论金：黄金原油全面走势分析策略独家指导
    [附源码]Python计算机毕业设计Django居家养老服务系统小程序
    JavaWeb基础（一）——Tomcat介绍
    ThreadLocal详解
    32 道 Spring 常见面试总结（附详细参考答案），我经常拿来面试别人
    SqlSugar安装使用和插入、更新、删除等基本操作
  • 原文地址：https://blog.csdn.net/fangyuxuan123/article/details/128131601