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;
}

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