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

柔情只为你懂 2022-03-28 16:52 358阅读 0赞

//一元运算符重载
    #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(5, 5);
        //前置++  （先自身++，在进行运算）
        //全局函数 运算符重载
        ++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(2, 2);
        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");
    }