12/1作业

#include <iostream>

using namespace std;

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);
private:
    int a;
    int b;
public:
    Person(){}
    Person(int a,int b):a(a),b(b)
    {}
    //成员函数实现-号运算符重载
    //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;
    //    }
    void show()
    {
        cout << "a = " << a << endl;
        cout << "b = " << b << endl;

    }

};
//全局函数实现+号运算符重载
const Person operator-(const Person &L,const Person &R)//L,R是左操作数，右操作数参数，进行传参操作
{
    Person temp;
    temp.a = L.a + R.a;
    temp.b = L.b +R.b;
    //全局函数，需要从外部的类中读取private部分的数据，因此需要从传的参数中进行读取左值跟右值
    return  temp;
}
//全局函数实现>号运算符重载
bool operator<(const Person &L,const Person &R)//L,R是左操作数，右操作数参数，进行传参操作
{
    if(L.a < R.a && L.b<R.b) //全局函数，需要从外部的类中读取private部分的数据，因此需要从传的参数中进行读取左值跟右值
    {
        return true;
    }
    else
    {
        return false;
    }
}
//全局函数实现-=号运算符重载
//全局函数，需要从外部的类中读取private部分的数据，因此需要从传的参数中进行读取左值跟右值
Person &operator-=(Person &L,const Person &R)
{
    L.a-=R.a;
    L.b-=R.b;
    return L;//返回左操作数自身
}
int main()
{
    Person p1(10,20);
    Person p2(10,20);

//    //简化版本
//    Person p3 =p1-p2;
//全局函数本质：Person p3 = p1.operator-(p2)
//    p3.show();

    //简化版本
    Person p3 =p1-p2;//全局函数本质：Person p3 =operator-(p1,p2)
    p3.show();

    //    //简化版本
    //    if(p3<p1)//成员函数本质:p3.operator<(p1)
    //    {
    //        cout << "p3 < p1" << endl;
    //    }

    //简化版本
    if(p3 < p1)//全局函数本质:operator<(p3,p1)
    {
      cout << "p3 > p1" << endl;
    }
    //    //简化版本
    //    Person p1-=p3;
    //全局函数本质：Person p1 = p1.operator-=(p3)
    //    p3.show();

        //简化版本
        p1  -= p3;//全局函数本质：operator-=(p1,p3)
        p1.show();
    return 0;
}