C++之单目运算符重载

这里以“-”(负号，不是减号)为例：
先用成员函数重载来实现：

class Complex{
private:
    float _x;
    float _y;
public:
    Complex(float x = 0, float y = 0):_x(x), _y(y){}
    void dis(){
        cout << "( " << _x << "," << _y << " )" << endl;
    }
    Complex operator-(){
        Complex t;
        t._x = -this->_x;
        t._y = -this->_y;
        return t;

    }
};

int main()
{
    int a = 10;
    cout << -a << endl;
    cout << -(-a) << endl;

    cout << "------------------" << endl;

    Complex c(1, 1);
    Complex t(2, 2);
    (-c).dis();
    (-(-c)).dis();
    return 0;
}

运行结果如下：

可以看出没有错，这里要注意，进行负号操作，并没有改变对象值的本身，所以这里不能直接操作对象本身，需要重建一个新对象，下面多加一步操作：

int main()
{
    int a = 10;
    cout << -a << endl;
    cout << -(-a) << endl;
    (-a) = 20;  //编译报错

    cout << "------------------" << endl;

    Complex c(1, 1);
    Complex t(2, 2);
    (-c).dis();   
    (-(-c)).dis();    
    (-c) = t;    
    return 0;
}

运算符重载不变，对于

(-a) = 20;

这么一个普通变量，系统是不允许这么操作的，左值不允许是运算，但

(-c) = t;    

缺编译通过了，现在这是不可以的，那么就会说将运算符重载的函数返回值类型改成const就可以了，下面就改一下：

class Complex{
private:
    float _x;
    float _y;
public:
    Complex(float x = 0, float y = 0):_x(x), _y(y){}
    void dis(){
        cout << "( " << _x << "," << _y << " )" << endl;
    }
    const Complex operator-(){
        Complex t;
        t._x = -this->_x;
        t._y = -this->_y;
        return t;

    }
};

int main()
{
    int a = 10;
    cout << -a << endl;
    cout << -(-a) << endl;
    (-a) = 20;   //编译报错

    cout << "------------------" << endl;

    Complex c(1, 1);    
    Complex t(2, 2);
    (-c).dis();    //编译报错
    (-(-c)).dis();    //编译报错
    (-c) = t;    //编译报错
    return 0;
}

(-c) = t;的确是报错了，但是

(-c).dis();    //编译报错
(-(-c)).dis();    //编译报错

这两句也同样报错了，因为把返回值类型改成const complex，那么(-c)变成了const对象，当时说const对象时说过const对象必须保证不能修改数据成员，所以只能调用const的成员函数，这里把(-(-c))转换一下:

(c.operator-()).operator-();

第一个c.operator-()返回一个const complex对象，再调用operator-()自然就会出错，又因为dis同样不是const成员函是，两者都报错是必然的。那么再修改一下：

class Complex{
private:
    float _x;
    float _y;
public:
    Complex(float x = 0, float y = 0):_x(x), _y(y){}
    void dis(){
        cout << "( " << _x << "," << _y << " )" << endl;
    }
    void dis() const{
        cout << "( " << _x << "," << _y << " )" << endl;
    }
    const Complex operator-()const{
        Complex t;
        t._x = -this->_x;
        t._y = -this->_y;
        return t;

    }
};

int main()
{
    int a = 10;
    cout << -a << endl;
    cout << -(-a) << endl;
    (-a) = 20;    //编译报错

    cout << "------------------" << endl;

    Complex c(1, 1);
    Complex t(2, 2);
    (-c).dis();
    (-(-c)).dis();
    (-c) = t;    //编译报错
    return 0;
}

这样就只有该报错的报错，不该报错的通过喽。

然后再用友元函数重载一下：

class Complex{
private:
    float _x;
    float _y;
public:
    Complex(float x = 0, float y = 0):_x(x), _y(y){}
    void dis(){
        cout << "( " << _x << "," << _y << " )" << endl;
    }
    void dis() const{
        cout << "( " << _x << "," << _y << " )" << endl;
    }
    friend const Complex operator-(const Complex &a){
        Complex t;
        t._x = -a._x;
        t._y = -a._y;
        return t;

    }
};

int main()
{
    int a = 10;
    cout << -a << endl;
    cout << -(-a) << endl;
    (-a) = 20;    //编译报错

    cout << "------------------" << endl;

    Complex c(1, 1);
    Complex t(2, 2);
    (-c).dis();
    (-(-c)).dis();
    (-c) = t;     //编译报错
    return 0;
}

可以看出来，友元重载有一个参数，而成员函数重载没有参数，跟双目运算符重载一样，友元重载比成员函数重载多一个参数。

还可以看出来这里友元要比成员函数重载略简单一些。而前面+=双目重载则是成员函数重载要简单一些，实际应该用友元重载还是成员函数重载还要自己多敲代码，比较一下那个方便用那个就好。

最后再举个前- -和后- -的例子：

1、前- -

class Complex{
private:
    float _x;
    float _y;
public:
    Complex(float x = 0, float y = 0):_x(x), _y(y){}
    void dis(){
        cout << "( " << _x << "," << _y << " )" << endl;
    }
    Complex& operator--(){
        --this->_x;
        --this->_y;
        return *this;
    }
};

int main()
{
    int a = 10;
    --a;
    cout << a << endl;
    (--a) = 20;
    cout << a << endl;

    cout << "-----------------------" << endl;

    Complex c(10, 10);
    Complex b(20, 20);
    (--c).dis();
    (--c) = b;
    c.dis();

    return 0;
}

运行结果是这样的:

可以看到结果是正确的。返回类型为什么是引用类型这里就不重复解释了，双目运算符重载中有说明。
同时，也可以看出，前- -是可以作为左值的。

再给出个友元重载：

friend Complex& operator--(Complex &a){
    --a._x;
    --a._y;
    return a;
}

运行结果同样是正确的，在这就不截图了。

2、后- -

class Complex{
private:
    float _x;
    float _y;
public:
    Complex(float x = 0, float y = 0):_x(x), _y(y){}
    void dis(){
        cout << "( " << _x << "," << _y << " )" << endl;
    }
    void dis() const{
        cout << "( " << _x << "," << _y << " )" << endl;
    }
    const Complex operator--(int){
        Complex t = *this;
        this->_x--;
        this->_y--;
        return t;
    }
};

int main()
{
    int a = 10;
    cout << a-- << endl;
    cout << a << endl;
    (a--) = 20;    //编译报错

    cout << "-----------------------" << endl;

    Complex c(10, 10);
    Complex d = c--;
    d.dis();
    c.dis();
    Complex b(20, 20);
    (c--) = b;    //编译报错

    return 0;
}

后–不同于前- -，比如a- -，先做a = a， 再做 a = a - 1;的操作，同时重载的参数中有一个int的哑元（也就是说有类型，没有名字的参数），重载函数中，要先赋值，再做-1的操作，这里要注意三个问题：

第一个问题：做–操作的对象是谁，是对象本身，还是函数中重新定义的对象t， 当然操作的是对象本身，而并不是对象t；

第二个问题：函数应该返回的是谁，应该返回对象本身，还是对象t，首先知道b = a- -;这里b = a; 还是b = a - 1; 显然b = a; 那么就应该返回t，也就是说对象–之前的值。

第三个问题：后- -操作是不能作为左值的，那么就要返回一个const complex，这样不准改变返回的值，自然就不能当左值了。

同时还有个要说明的，像下面这样：

a----;
c----;

后–是不允许连用的，这也是通过将返回值类型改成const来限制的。而前–是可以连用的，没有const的限制。

再用友元函数重载实现如下：

friend const Complex operator--(Complex & a, int){
    Complex t = a;
    a._x--;
    a._y--;
    return t;
}

单目运算符重载就说到这，还是要多联系，多敲代码才是王道。