C/C++ 之 ‘++’、‘+’、‘+=’、‘-’、‘（）’、‘--’ 操作符的重载实现重载

末蓝、 2022-08-08 19:36 182阅读 0赞

1. 操作符（\++，\+,+=,小于号等）重载

**新建QT项目，编写头文件**

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#ifndef DIALOG\_H
2.  \#define DIALOG\_H
3.  
4.  \#include <QDialog>
5.  \#include<QLabel>
6.  
7.  **namespace** Ui \{ 
8.  **class** Dialog; 
9.  \} 
10. 
11. //编写自己的Label
12. **class** myLabel 
13. \{ 
14. **public**: //一定要是共有的，才可以被调用
15.  QLabel \*ql; 
16. **int** cx; 
17. **int** cy; 
18.  myLabel() 
19.  \{ 
20.  ql=**new** QLabel("12345") ; 
21.  cx=cy=300; 
22.  ql->move(cx,cy);//移动位置
23.  \} 
24.  ~myLabel() 
25.  \{ 
26. **delete** ql; 
27.  \} 
28. **void** show() 
29.  \{ 
30.  ql->show(); 
31.  \} 
32. \}; 
33. 
34. 
35. **class** Dialog : **public** QDialog 
36. \{ 
37.  Q\_OBJECT 
38. 
39. **public**: 
40. **int** x;//长，宽
41. **int** y; 
42. **int** cx;//移动到的位置x坐标
43. **int** cy; 
44. 
45. **public**: 
46. **explicit** Dialog(QWidget \*parent = 0); 
47. //通过友元函数进行重载
48. **friend****void** operator +=(Dialog &d,myLabel &my); 
49.  ~Dialog(); 
50. 
51. //重载右加号
52. **void** operator ++(); 
53. 
54. **void** setxy(); 
55. **void** settoxy(**int** a,**int** b); 
56. 
57. //二元运算符,重载+号
58.  Dialog \* operator +(Dialog **const** &adddata); 
59. 
60. //重载等号
61.  Dialog \*operator =(Dialog **const** &setdata); 
62. 
63. //重载+=
64.  Dialog \*operator +=(**int** length); 
65. 
66. //重载<
67. **bool** operator < (Dialog **const** &data); 
68. 
69. **private**: 
70.  Ui::Dialog \*ui; 
71. \}; 
72. 
73. \#endif // DIALOG\_H

**编写头文件的实现类**

[cpp] 
        
         view plain
        
         copy
        
         print
        
         ?
        
         
       
        
      
       
      
       
        #include "dialog.h"   
        #include "ui_dialog.h"   
           
        Dialog::Dialog(QWidget *parent) :   
            QDialog(parent),   
            ui(new Ui::Dialog)   
        {   
            ui->setupUi(this);   
            x = y = 300;   
            //将窗口大小固定   
            this->resize(x,y);   
            cx = cy = 0;   
            this->move(cx,cy);   
        }   
           
        Dialog::~Dialog()   
        {   
            delete ui;   
        }   
           
        //重载左加号,语法：括号里面有int，默认后++，没有int，默认前--   
        void Dialog::operator ++()   
        {   
            this->cx++;   
            this->cy++;   
            this->move(cx,cy);   
        }   
           
        void Dialog::setxy()   
        {   
            this->resize(x,y);   
        }   
        void Dialog::settoxy(int a,int b)   
        {   
            this->x = a;   
            this->y = b;   
        }   
           
        //二元运算符,重载+号   
        Dialog * Dialog::operator +(Dialog const &adddata)   
        {   
            Dialog *p=new Dialog;   
            p->x=this->x+adddata.x;   
            p->y=this->y+adddata.y;   
            return p;   
        }   
           
        //重载等号   
        Dialog * Dialog::operator =(Dialog const &setdata)   
        {   
            this->x = setdata.x;   
            this->y = setdata.y;   
            this->setxy();   
            return this;   
        }   
           
        //重载+=，如果+号前的变量和定义的变量类型一致，只需要一个参数   
        Dialog * Dialog::operator +=(int length)   
        {   
            this->x+= length;   
            this->y+= length;   
            this->setxy();   
            return this;   
        }   
           
        //重载<   
        bool Dialog::operator < (Dialog const &data)   
        {   
            return (this->x * this->y) < (data.x * data.y);   
        }

**编写主函数**

[cpp] 
        
         view plain
        
         copy
        
         print
        
         ?
        
         
       
        
      
       
      
       
        #include "dialog.h"   
        #include <QApplication>   
        #include <windows.h>   
        #include <QDebug>   
           
        //在栈上定义一个临时的Dialog,显示，然后休眠2秒钟后消失   
        void add(Dialog &add1,Dialog &add2)   
        {   
            Dialog temp; //栈上,用完了马上回收   
            temp.x = add1.x + add2.x;   
            temp.y = add1.y + add2.y;   
            temp.show();   
            temp.setxy();   
            //发现这里在停留2秒钟后，窗口消失了。   
            Sleep(2000);   
        }   
           
        //在堆上，只有自己回收才消失   
        Dialog * addX(Dialog &add1,Dialog &add2)   
        {   
            //在堆上创建一个Dialog,只有当自己回收了的时候才会被销毁   
            Dialog *p = new Dialog;   
            p->x = add1.x + add2.x;   
            p->y = add1.y + add2.y;   
            p->show();   
            p->setxy();   
            return p;   
        }   
           
        //测试方法的方式实现+操作   
        //1.（分为两种情况：1.栈上，2，堆上）   
        //2.通过重载+操作符的方式实现   
        int main1(int argc, char *argv[])   
        {   
            QApplication a(argc, argv);   
            Dialog w1;   
            //不管最终怎样，因为这里使用了w1.show()所以永远有下面窗口   
            w1.show();   
            Dialog w2;   
            //不管最终怎样，因为这里使用了w1.show()所以永远有下面窗口   
            w2.show();   
            add(w1,w2);   
           
            //下面开始使用在堆上创建窗口的方式演示效果，最后   
            Dialog *p = addX(w1,w2);   
            //显示窗口   
            p->show();   
           
            //下面通过重载+号的方式显示窗口   
            Dialog *p2 = w1 + w2;   
            p2->setxy();   
            p2->show();   
           
            return a.exec();   
        }   
           
        //重载右++,因为右边没有参数，所以就不需要带参数   
        int main2(int argc,char *argv[])   
        {   
            QApplication a(argc,argv);   
            Dialog w;   
            w.show();   
            //将窗口先移动到（0,0）位置   
            w.move(0,0);   
            for(int i=0;i<400;i++)   
            {   
                //重载左加号,语法：括号里面有int，默认后++，没有int，默认前--   
                ++w;   
                Sleep(5);   
            }   
           
            return a.exec();   
        }   
           
        //>   
        //=   
        //+=   
        //友元重载+=，=不同类的对象的位置,因为这里的泛型是类，所以下面使用class   
        template<class T>   
        void showall(T* myt)   
        {   
            myt->show();   
        }   
        //测试上面的友元函数，测试重载函数，+=重载   
        //友元函数的好处：访问私有变量   
        //如果重载的时候，用到私有变量的时候，不需要友元   
        int main3(int argc,char *argv[])   
        {   
            QApplication a(argc,argv);   
            //调用默认的Label，如果只写下面这两句，也会显示一个带有Label的小窗口   
            QLabel *ql = new QLabel("1234567");   
            ql->show();   
           
            myLabel label1;   
            showall(&label1);//通过模板的方式实现显示label   
           
            //再定义一个Label，验证上面的重载函数   
            Dialog w1;   
            //下面传递一个指针   
            showall(&w1);   
           
            return a.exec();   
        }   
           
        //测试=,+=,<操作符   
        int main(int argc,char *argv[])   
        {   
            QApplication a(argc,argv);   
            Dialog w1;   
            w1.setWindowTitle("w1窗口");   
            w1.show();   
            w1.settoxy(400,700);   
            w1.setxy();   
            Dialog w2;   
            w2.setWindowTitle("w2窗口");   
            w2.show();   
            w2.settoxy(700,400);   
            w2.setxy();   
            //使用重载的=号操作符，运行效果是窗口2的大小和窗口1的大小一样了   
            //如果下面的这行注释掉，那么就发现两个窗口大小变成一样了。   
            w1=w2;   
            w2.show();   
           
            Dialog w3;   
            w3.setWindowTitle("w3窗口");   
            w3.show();   
            w3.settoxy(300,1050);   
            w3.setxy();   
            w3+=230;   
            w3.show();   
           
            //<重载的是面积比大小   
            qDebug() << (w1 < w2);   
            qDebug() << (w2 < w3);   
           
            return a.exec();   
        }

2.重载--，（）操作符的代码：

头文件：

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#ifndef DIALOG\_H
2.  \#define DIALOG\_H
3.  
4.  \#include <QDialog>
5.  
6.  **namespace** Ui \{ 
7.  **class** Dialog; 
8.  \} 
9.  
10. **class** Dialog : **public** QDialog 
11. \{ 
12.  Q\_OBJECT 
13. 
14. **public**: 
15. **int** x; 
16. **int** y; 
17. //重载++操作符
18. **void** operator ++(); 
19. //重载--操作符
20. **void** operator --(); 
21. //重载（）
22. **void** operator ()(**int** num); 
23. //重载+操作符，创建窗口的时候在堆上
24.  Dialog \* operator +(Dialog & adddata2); 
25. **void** setxy(**int** a,**int** b) 
26.  \{ 
27. **this**\->x = a; 
28. **this**\->y = b; 
29. **this**\->resize(**this**\->x,**this**\->y); 
30.  \} 
31. 
32. **public**: 
33. **explicit** Dialog(QWidget \*parent = 0); 
34.  ~Dialog(); 
35. 
36. **private**: 
37.  Ui::Dialog \*ui; 
38. \}; 
39. 
40. \#endif // DIALOG\_H

头文件的实现类

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#include "dialog.h"
2.  \#include "ui\_dialog.h"
3.  
4.  Dialog::Dialog(QWidget \*parent) : 
5.   QDialog(parent), 
6.   ui(**new** Ui::Dialog) 
7.  \{ 
8.   ui->setupUi(**this**); 
9.  **this**\->x = 300; 
10. **this**\->y = 400; 
11. **this**\->resize(x,y); 
12. \} 
13. 
14. Dialog::~Dialog() 
15. \{ 
16. **delete** ui; 
17. \} 
18. 
19. //重载++操作符
20. **void** Dialog::operator ++() 
21. \{ 
22. **this**\->x++; 
23. **this**\->y++; 
24. **this**\->resize(x,y); 
25. \} 
26. 
27. //重载--操作符
28. **void** Dialog::operator --() 
29. \{ 
30. **this**\->x--; 
31. **this**\->y--; 
32. **this**\->resize(x,y); 
33. \} 
34. 
35. //重载（）
36. **void** Dialog::operator ()(**int** num) 
37. \{ 
38. **this**\->x = num; 
39. **this**\->y = num / 2; 
40. **this**\->resize(x,y); 
41. \} 
42. //重载+操作符，创建窗口的时候在堆上
43. Dialog \* Dialog::operator +(Dialog & adddata2) 
44. \{ 
45.  Dialog \*p=**new** Dialog; 
46.  p->x=**this**\->x+adddata2.x; 
47.  p->y=**this**\->x+adddata2.y; 
48.  p->resize(p->x,p->y); 
49.  p->show(); 
50. **return** p; 
51. \}

主函数所在类

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#include "dialog.h"
2.  \#include <QApplication>
3.  
4.  **int** main(**int** argc, **char** \*argv\[\]) 
5.  \{ 
6.   QApplication a(argc, argv); 
7.   Dialog w; 
8.   w.show(); 
9.  **for**(**int** i = 0;i<800;i++) 
10.  \{ 
11.  \++w; 
12.  \} 
13. **for**(**int** i=800;i>0;i++) 
14.  \{ 
15.  \--w; 
16.  \} 
17. **for**(**int** i = 1000;i>300;i--) 
18.  \{ 
19.  w(i); 
20.  \} 
21. 
22. **return** a.exec(); 
23. \}

3.通过友元的方式重载操作<<和>>还有\+操作符

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#include<iostream>
2.  **using****namespace** std; 
3.  
4.  **class** mycomplex 
5.  \{ 
6.  **public**: 
7.  //友元，需要操作类的内部
8.  //ostream,引用标准输入输出流
9.  **friend** ostream & operator <<(ostream & out, mycomplex & Complex); 
10. **friend** istream & operator >>(istream & in, mycomplex & Complex); 
11. **friend** mycomplex operator +(mycomplex adddata1, mycomplex adddata2); 
12. **friend** mycomplex operator +(mycomplex adddata1, **int** x); 
13. //友元函数可以处理不同的类型交错
14. //成员函数不能实现的，友元函数都可以实现
15. **int** x; 
16. **int** y; //x,y坐标
17. //没有构造无法使用this初始化
18.  mycomplex() 
19.  \{ 
20. **this**\->x = 0; 
21. **this**\->y = 0; 
22.  \} 
23. //构造函数重载
24.  mycomplex(**int** x, **int** y) :x(x), y(y) 
25.  \{ 
26.  \} 
27.  ~mycomplex() 
28.  \{ 
29.  \} 
30. 
31. **void** show() 
32.  \{ 
33.  std::cout << x << "+" << y << "i" << std::endl; 
34.  \} 
35. //重载++操作符
36. **void** operator ++() 
37.  \{ 
38. **this**\->x++; 
39. **this**\->y++; 
40.  \} 
41. //重载--操作符
42. **void** operator --(); 
43. 
44. //重载函数调用运算符，变量名可以当作一个函数调用参数，返回结果
45. **int** operator()(**int** num) 
46.  \{ 
47.  cout << num << endl; 
48. **return** num + num; 
49.  \} 
50. **protected**: 
51. **private**: 
52. \}; 
53. 
54. **void** mycomplex::operator--() 
55. \{ 
56. **this**\->x--; 
57. **this**\->y--; 
58. \} 
59. 
60. //输入输出，cout，屏幕，fout文件
61. ostream & operator <<(ostream & out, mycomplex & Complex) 
62. \{ 
63.  out << Complex.x << "+" << Complex.y << "i" << std::endl; 
64. **return** out; 
65. \} 
66. 
67. istream & operator >>(istream & in, mycomplex & Complex) 
68. \{ 
69.  cout << "请输入X,Y" << endl; 
70.  in >> Complex.x >> Complex.y; 
71. **return** in; 
72. \} 
73. 
74. mycomplex operator +(mycomplex adddata1, mycomplex adddata2) 
75. \{ 
76.  mycomplex temp; 
77.  temp.x = adddata1.x + adddata2.x; 
78.  temp.y = adddata1.y + adddata2.y; 
79. **return** temp; 
80. \} 
81. 
82. mycomplex operator + (mycomplex adddata1, **int** x) 
83. \{ 
84.  mycomplex temp; 
85.  temp.x = adddata1.x + x; 
86.  temp.y = adddata1.y + x; 
87. **return** temp; 
88. \} 
89. 
90. **void** main() 
91. \{ 
92.  mycomplex my1(7,8),my2(9,10); 
93. //my1+my2这里+实现了重载功能，返回的是一个mycomplex对象，其中<<又被重载了
94.  std::cout << my1 + my2 << std::endl; 
95. //my1+3这里+实现了重载功能，返回的是一个mycomplex对象，其中<<又被重载了
96.  std::cout << my1 + 3 << std::endl; 
97.  std::cin.get(); 
98. \}

运行结果：

![SouthEast][]

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **void** main() 
2.  \{ 
3.   mycomplex my1; 
4.  //>>调用了重载
5.   cin >> my1; 
6.   cout << my1; 
7.  //my1++;
8.  //左加加，括号中不需要带参数
9.   \++my1; 
10.  cout << my1; 
11.  my1--; 
12.  cout << my1; 
13. //下面每行执行的时候分别输出了2行数据。
14.  std::cout << my1(1) << std::endl; 
15.  std::cout << my1(2) << std::endl; 
16.  std::cin.get(); 
17.  std::cin.get(); 
18. \}

运行结果如下：

![SouthEast 1][]

[view plain]: http://blog.csdn.net/tototuzuoquan/article/details/38736667#
[SouthEast]: /images/20220731/fd36ebb9dff949f8a67d11e4c893d603.png
[SouthEast 1]: /images/20220731/551f192a0fa24f75a464ab611ea87074.png