首页 > 代码库 > 操作符(++,+,+=,小于号,(),--等)重载

操作符(++,+,+=,小于号,(),--等)重载



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

运行结果如下: