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

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

新建QT项目，编写头文件

 #ifndef DIALOG_H
 #define DIALOG_H

 #include <QDialog>
 #include<QLabel>

 namespace Ui {
 class Dialog;
 }

 //编写自己的Label
 class myLabel
 {
 public: //一定要是共有的，才可以被调用
     QLabel *ql;
      int cx;
      int cy;
      myLabel()
      {
          ql=new QLabel("12345") ;
          cx=cy=300;
          ql->move(cx,cy);//移动位置
      }
      ~myLabel()
      {
         delete ql;
      }
     void  show()
     {
        ql->show();
     }
 };


 class Dialog : public QDialog
 {
     Q_OBJECT

 public:
     int x;//长，宽
     int y;
     int cx;//移动到的位置x坐标
     int cy;

 public:
     explicit Dialog(QWidget *parent = 0);
     //通过友元函数进行重载
     friend void operator +=(Dialog &d,myLabel &my);
     ~Dialog();

     //重载右加号
     void operator ++();

     void setxy();
     void settoxy(int a,int b);

     //二元运算符,重载+号
     Dialog * operator +(Dialog const &adddata);

     //重载等号
     Dialog *operator =(Dialog const &setdata);

     //重载+=
     Dialog *operator +=(int length);

     //重载<
     bool operator < (Dialog const &data);

 private:
     Ui::Dialog *ui;
 };

 #endif // DIALOG_H

编写头文件的实现类

  
  
  
  
#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);
}

编写主函数

  
  
  
  
#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.重载--，（）操作符的代码：

头文件：

 #ifndef DIALOG_H
 #define DIALOG_H

 #include <QDialog>

 namespace Ui {
 class Dialog;
 }

 class Dialog : public QDialog
 {
     Q_OBJECT

 public:
     int x;
     int y;
     //重载++操作符
     void operator ++();
     //重载--操作符
     void operator --();
     //重载（）
     void operator ()(int num);
     //重载+操作符，创建窗口的时候在堆上
     Dialog * operator +(Dialog & adddata2);
     void setxy(int a,int b)
     {
         this->x = a;
         this->y = b;
         this->resize(this->x,this->y);
     }

 public:
     explicit Dialog(QWidget *parent = 0);
     ~Dialog();

 private:
     Ui::Dialog *ui;
 };

 #endif // DIALOG_H

头文件的实现类

 #include "dialog.h"
 #include "ui_dialog.h"

 Dialog::Dialog(QWidget *parent) :
     QDialog(parent),
     ui(new Ui::Dialog)
 {
     ui->setupUi(this);
     this->x = 300;
     this->y = 400;
     this->resize(x,y);
 }

 Dialog::~Dialog()
 {
     delete ui;
 }

 //重载++操作符
 void Dialog::operator ++()
 {
     this->x++;
     this->y++;
     this->resize(x,y);
 }

 //重载--操作符
 void Dialog::operator --()
 {
     this->x--;
     this->y--;
     this->resize(x,y);
 }

 //重载（）
 void Dialog::operator ()(int num)
 {
     this->x = num;
     this->y = num / 2;
     this->resize(x,y);
 }
 //重载+操作符，创建窗口的时候在堆上
 Dialog * Dialog::operator +(Dialog & adddata2)
 {
     Dialog  *p=new Dialog;
     p->x=this->x+adddata2.x;
     p->y=this->x+adddata2.y;
     p->resize(p->x,p->y);
     p->show();
     return p;
 }

主函数所在类

 #include "dialog.h"
 #include <QApplication>

 int main(int argc, char *argv[])
 {
     QApplication a(argc, argv);
     Dialog w;
     w.show();
     for(int i = 0;i<800;i++)
     {
         ++w;
     }
     for(int i=800;i>0;i++)
     {
         --w;
     }
     for(int i = 1000;i>300;i--)
     {
         w(i);
     }

     return a.exec();
 }

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

 #include<iostream>
 using namespace std;

 class mycomplex
 {
 public:
     //友元，需要操作类的内部
     //ostream,引用标准输入输出流
     friend ostream & operator <<(ostream & out, mycomplex & Complex);
     friend istream & operator >>(istream & in, mycomplex & Complex);
     friend   mycomplex  operator +(mycomplex adddata1, mycomplex adddata2);
     friend   mycomplex  operator +(mycomplex adddata1, int x);
     //友元函数可以处理不同的类型交错
     //成员函数不能实现的，友元函数都可以实现
     int x;
     int y;   //x,y坐标
     //没有构造无法使用this初始化
     mycomplex()
     {
         this->x = 0;
         this->y = 0;
     }
     //构造函数重载
     mycomplex(int x, int y) :x(x), y(y)
     {
     }
     ~mycomplex()
     {
     }

     void show()
     {
         std::cout << x << "+" << y << "i" << std::endl;
     }
     //重载++操作符
     void operator ++()
     {
         this->x++;
         this->y++;
     }
     //重载--操作符
     void operator --();

     //重载函数调用运算符，变量名可以当作一个函数调用参数，返回结果
     int operator()(int num)
     {
         cout << num << endl;
         return num + num;
     }
 protected:
 private:
 };

 void mycomplex::operator--()
 {
     this->x--;
     this->y--;
 }

 //输入输出，cout，屏幕，fout文件
 ostream & operator <<(ostream & out, mycomplex & Complex)
 {
     out << Complex.x << "+" << Complex.y << "i" << std::endl;
     return out;
 }

 istream & operator >>(istream & in, mycomplex & Complex)
 {
     cout << "请输入X,Y" << endl;
     in >> Complex.x >> Complex.y;
     return in;
 }

 mycomplex  operator +(mycomplex adddata1, mycomplex adddata2)
 {
     mycomplex temp;
     temp.x = adddata1.x + adddata2.x;
     temp.y = adddata1.y + adddata2.y;
     return temp;
 }

 mycomplex operator + (mycomplex adddata1, int x)
 {
     mycomplex temp;
     temp.x = adddata1.x + x;
     temp.y = adddata1.y + x;
     return temp;
 }

 void main()
 {
     mycomplex my1(7,8),my2(9,10);
     //my1+my2这里+实现了重载功能，返回的是一个mycomplex对象，其中<<又被重载了
     std::cout << my1 + my2 << std::endl;
     //my1+3这里+实现了重载功能，返回的是一个mycomplex对象，其中<<又被重载了
     std::cout << my1 + 3 << std::endl;
     std::cin.get();
 }

运行结果：

 

 void main()
 {
     mycomplex my1;
     //>>调用了重载
     cin >> my1;
     cout << my1;
     //my1++;
     //左加加，括号中不需要带参数
     ++my1;
     cout << my1;
     my1--;
     cout << my1;
     //下面每行执行的时候分别输出了2行数据。
     std::cout << my1(1) << std::endl;
     std::cout << my1(2) << std::endl;
     std::cin.get();
     std::cin.get();
 }

运行结果如下：