我们都知道C++中的关键字 operator 具有两方面意义

operator 作为类的转换函数:

1.解释：将类的对象转换为其他类型。比如说将一个类的对象转换为int类型

2.形式：operator <类型>（）

3.条件：

• 转换函数必须是类的方法
• 转换函数不能指定返回类型，但是实现方法里需有返回值
• 转换函数不能有参数

例如：

class MyClass
{
public:
    MyClass() {}

    //类的转换函数：声明不能有返回值
    operator int ()
    {
        qDebug() << "conver to int";
        return 1;           //实现函数里需有返回值
    }
};


int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    MyClass a;
    int b = (int)a;         //类对象转换，显示转换
    qDebug() << "b=" << b;  //转换后的值
    qDebug() << "a=" << a;  //隐式转换

    return app.exec();
}

输出结果为：

//输出结果为
conver to int
b= 1
conver to int
a= 1

operator 在类中作为重载运算符:

关键字operator 与运算符一起使用，表示一个运算符函数。 我们要将operator+ 整体上视为一个函数名。

那么为什么要使用操作符重载呢？

        对于系统所有的操作符，比如+/-/*/%/!=/=等操作符，只支持基本的数据类型和标准数据库中自定义的类。

        如果对于我们自定义的一个类MyClass呢？我们想实现两个MyClass类的对象A、B，他们是无法实现加减乘除、比较大小、判断是否相等等操作的。如果我们想实现自定义类得对象A、B的上述操作呢？这时候就需要我们来实现运算符的重载。

解释：使用运算符对类之间的运算。比如类的两个对象进行+/-/*/%/!=/=等运算

形式: <类型> operator <运算符>（参数表>）

方法：使用成员函数与友元函数

1.成员函数，作为一个类的成员函数结果会更改原来类的结果。

2.友元函数（）

class MyClass
{
public:
    MyClass() {}
    MyClass(int a, float b):m_a(a),m_b(b) {}

    int getA() {return m_a;}
    float getB() {return m_b;}

    MyClass operator +(const MyClass &add)
    {
        m_a = m_a + add.m_a;
        m_b = m_b + add.m_b;

        return *this; //将更改 + 前对象的成员值。
    }

    friend MyClass operator -(const MyClass &A, const MyClass &B)
    {
        MyClass sub;
        sub.m_a = A.m_a - B.m_a;
        sub.m_b = A.m_b - B.m_b;

        return sub;    //创建临时变量作为结果的存储，不会更改 - 号前后的两个对象的值
    }

private:
    int     m_a;
    float   m_b;
};


int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    MyClass A(10, 5.0);
    MyClass B(5, 2.0);

    MyClass add = A + B;

    MyClass sub = A - B;

    qDebug() << "add.a = " << add.getA() << "add.b = " << add.getB();

    qDebug() << "sub.a = " << sub.getA() << "sub.b = " << sub.getB();
    return app.exec();
}

//执行结果
add.a =  15 add.b =  7
sub.a =  10 sub.b =  5