c++(运算符重载静态成员)

思维导图：
复习：
cpp 复制代码
class Person
{
    friend const Person operator+(const Person &L,const Person &R);
    friend bool operator>(const Person &L,const Person &R);
    friend Person &operator+=(Person &L,const Person &R);
    friend Person &operator++(Person &O);
    friend const Person operator++(Person &O,int);
private:
    int a;
    int b;
public:
    //无参构造
    Person(){}
    //有参构造
    Person(int a,int b):a(a),b(b){}
    //显示函数
    void show()
    {
        cout << "a=" << a << " " << "b=" << b << endl;
    }
    //成员函数实现+运算重载
//    const Person operator+(const Person &R)const
//    {
//        Person temp;
//        temp.a=a+R.a;
//        temp.b=b+R.b;
//        return temp;
//    }

    //成员函数实现>关系运算
//    bool operator>(const Person &R)const
//    {
//        if(a>R.a&&b>R.b)
//        {
//            return true;
//        }
//        else{
//            return false;
//        }
//    }

    //成员函数实现+=关系运算
//    Person &operator+=(const Person &R)
//    {
//        a+=R.a;
//        b+=R.b;
//        return *this;
//    }

    //成员函数实现 前++ 运算关系符运算
//    Person &operator++()
//    {
//        ++a;
//        ++b;
//        return *this;
//    }

//    //成员函数实现 后++ 运算关系符运算
//    const Person operator++(int)
//    {
//        Person temp;
//        temp.a=a++;
//        temp.b=b++;
//        return temp;
//    }

};

//全局函数实现+运算重载
const Person operator+(const Person &L,const Person &R)
{
    Person temp;
    temp.a=L.a+R.a;
    temp.b=L.b+R.b;
    return temp;
}
//全局函数实现>运算重载
bool operator>(const Person &L,const Person &R)
{
    if(L.a>R.a&&L.b>R.b)
    {
        return true;
    }
    else
    return false;
}
//全局函数实现+=关系运算
Person &operator+=(Person &L,const Person &R)
{
    L.a+=R.a;
    L.b+=R.b;
    return L;
}
//全局函数实现前++运算符重载
Person &operator++(Person &O)
{
    ++O.a;
    ++O.b;
    return O;
}
//成员函数实现 后++ 运算关系符运算
const Person operator++(Person &O,int)
{
    Person temp;
    temp.a=O.a++;
    temp.b=O.b++;
    return temp;
}

int main()
{
    Person p1(10,11);
    Person p2(10,11);
    //成员函数+简化版本
//    Person p3 = p1 + p2;//p1.operator(p2)
//    p3.show();
    //全局函数+
    Person p3 = p1 + p2;//operator+(p1,p2)
    p3.show();

    cout << "--------------------------" << endl;
    //成员函数>简化版本
//    if(p3>p1)//p3.operator>(p1)
//    {
//        cout << "p3>p1" << endl;
//    }
    //全局函数>简化版本
    if(p3>p1)//operator>(p3,p1)
    {
        cout << "p3>p1" << endl;
    }
    cout << "--------------------------" << endl;
    Person p4(2,6);
    p4.show();
    //成员函数+=简化版本
    p4+=p1;//p4.operate+=(p1)
    p4.show();
    cout << "--------------------------" << endl;
     //成员函数前++简化版本
    Person p5(6,6);
    ++p5;//p5.operator++()
    p5.show();
    cout << "--------------------------" << endl;
    //成员函数后++简化版本
    Person p7(8,8);
    p4=p7++;//p7.operator++(int)
    p7.show();
    p4.show();


    return 0;
}
c++(运算符重载 静态成员)

c++(运算符重载静态成员)
