//一元运算符重载
#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");
}