C++ 运算符重载二（一元运算符重载）

//一元运算符重载
#include<iostream>
using namespace std;

class Point
{
public:
    Point(int x,int y){
        this->x = x;
        this->y = y;
    }
    Point(Point &p){
        this->x = p.x;
        this->y = p.y;
        cout << "拷贝构造函数被执行了1" << endl;
    }
    ~Point(){
        cout << "析构函数被执行了2" << endl;
    }
    //加法
    friend Point operator+(Point p1, Point p2);
    //前置++
    friend Point& operator++(Point& pin);
    //前置--
    Point& operator--(){
        this->x--;
        this->y--;
        return *this;
    }
    //后置++
    friend Point operator++(Point& pin, int);
    //后置--
    Point operator--(int){
        Point temp = *this;
        this->x--;
        this->y--;
        return temp;
    }
    void PrintfA(){
        cout << "x=" << this->x << endl;
        cout << "y=" << this->y << endl;

    }

private:
    int x;
    int y;
};

//+
Point operator+(Point p1, Point p2){
    Point pres(p1.x + p2.x, p1.y + p2.y);
    return pres;
}

//前置++
Point& operator++(Point& pin){
    pin.x++;
    pin.y++;
    //注明此处不存在pin的构造，析构 因为pin这个对象一直存在
    return pin;
}

//后置++
//Point & operator++(Point& pin, int)多了一个占位int类型参数表示是后置运算符
//这是c++的语法，这个占位参数只能是Int类型
Point operator++(Point& pin, int){
    Point temp = pin;
    //这里使用临时变量是为了保存后置++之前的状态
    //因为后置++参加完运算后才会自增
    pin.x++;
    pin.y++;
    return temp;
}

void ProtectA(){
    Point p1(, );
    //前置++  （先自身++，在进行运算）
    //全局函数 运算符重载
    ++p1;
    //步骤1：首先承认运算符重载是一个函数
    //operator++()
    //步骤2：根据操作数，写出参数列表
    //operator++(p1)
    //步骤3：根据业务完成函数返回值，以及实现函数
    //Point& operator++(Point& pin);
    //此处的返回值为啥不是void呢？
    //前置++是自身变量的++（即对象本身的自增）,我传递的参数是引用，改变的就是对象本身，为啥还要将对象返回出来呢？
    //首先明确一点 运算符重载是一个函数，假设 p1+（++p2）  如果返回NULL  那么p1+这个运算就会有问题
    p1.PrintfA();

    //类的成员函数 运算符重载
    //前置--
    --p1;
    //步骤1：首先承认运算符重载是一个函数
    //operator--()
    //步骤2：根据操作数，写出参数列表
    //p1.operator--()
    //步骤3：根据业务完成函数返回值，以及实现函数
    //Point& operator--();
    p1.PrintfA();

    //全局函数 运算符重载
    //后置++（后置++ 必须运算完成之后，自身才可以自增）
    //p1++;
    //步骤1：首先承认运算符重载是一个函数
    //operator++()
    //步骤2：根据操作数，写出参数列表
    //operator++(Point& pin,int)
    //步骤3：根据业务完成函数返回值，以及实现函数
    //Point operator++(Point& pin, int)

    //特别注意：这里后置++的返回值必须是Point对象  不可以是引用
    //因为如果是引用，返回值是一个临时变量，执行return temp;之后这个临时变量会被销毁
    //引用的话会继续指向这个被销毁的临时变量，出现脏数据、
    //但是返回是Point（匿名对象）就会不一样，执行return temp;之后，c++编译器生成一个匿名对象
    //把临时变量拷贝到匿名对象中，执行Point p3 = p1++;，匿名对象会直接转化成p3，二不会被销毁
    //这样的结果才是正确的，因此我们需要改变operator+(Point p1, Point p2)函数，参数类型只能是Point
    //而不可以是Point &引用；因为p1+p2的返回值应该是一个临时变量，而不能改变p1或者p2本身的值
    //当然我并不是说operator+(Point &p1, Point &p2)重载+号就是错误，但是在本场景下，不能使用引用

    Point p2(, );
    Point p3 = p1++;
    Point p4 = p1 + (p2++);
    cout << "p4-------------------" << endl;
    p4.PrintfA();
    cout << "p2-------------------" << endl;
    p2.PrintfA();

    //类的成员函数 运算符重载
    //后置--
    cout << "后置-- p1的原先值" << endl;
    p1.PrintfA();
    p1--;
    cout << "后置-- p1的结果值" << endl;
    p1.PrintfA();
    //步骤1：首先承认运算符重载是一个函数
    //operator--()
    //步骤2：根据操作数，写出参数列表
    //operator--(int)
    //步骤3：根据业务完成函数返回值，以及实现函数
    //Point operator--(int)

}

void main(){
    ProtectA();
    system("pause");
}