运算符重载

 

引言：多态性是指同样的消息被不同类型的对象接受时会导致不同的行为。它可以分为：重载多态、强制多态、包含多态和参数多态。

编译和运行时都可以产生多态，前者是编译中确定同名操作的具体操作对象，后者为程序运行中动态地确定操作所针对的具体对象。

 

　　如在复数类中：

?
1
2
3
4
5
6
7
8
9
10
#include<iostream>
using namespace std;
class Complex {
public:
    Complex(double r=0.0,double i=0.0):real(r),imag(i){}
    void display()const;
private:
    double real;
    double imag;
};

　　

　　若在主函数中声明两个对象，想实现复数的加法，直接用+是会报错的，因为系统库中+并不支持用户自定义类的运算。这时就需要用到运算符重载：使同一个运算符作用于不同类型的数据导致不同的行为

　　重载需注意：（1）c++运算符中已有的才可以重载                                                 (2)重载后优先级与结合性不变                                          （3）不能改变操作对象个数，至少有一个操作对象是自定义类型

 

?
1
2
3
4
Complex operator +（Complex i,Complex j）
{
       return i.display()+j.display()         
}

　　

　　而类型强制转换运算符是单目运算符，也可以被重载，但只能重载为成员函数，不能重载为全局函数。经过适当重载后，（类型名）对象这个对对象进行强制类型转换的表达式就等价于对象.operator

类型名()，即变成对运算符函数的调用。

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
using namespace std;
class Complex
{
    double real, imag;
public:
    Complex(double r = 0, double i = 0) :real(r), imag(i) {};
    operator double() { return real; }  //重载强制类型转换运算符 double
};
int main()
{
    Complex c(1.2, 3.4);
    cout << (double)c << endl;  //输出 1.2
    double n = 2 + c;  //等价于 double n = 2 + c. operator double()
    cout << n;  //输出 3.2
}

　　自增++和自减--都是一元运算符，它的前置形式和后置形式都可以被重载。不过通过形参表中是否有int型进行区分：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Ball{
private:
    int radius;
public:
 
    //前自增
    Ball& operator++()　　 {
        ++(this->radius);
        return *this;
    }
 
    //后自增
    Ball& operator++(int)    {
        Ball ball = *this;
        ++*this;
        return ball;
    }
};