运算符重载

一、什么是运算符重载

  我们知道函数重载就是对已有的函数赋予新的含义，使之实现新的功能。因此，同一个函数可以实现不同的功能，也就是一名多用。

  运算符也可以重载，像我们平时使用的+运算符，对整形，单精度浮点型，双精度浮点型都能实现加法运算。又如，<<(左移)，在输出操作中与流对象cout配合使用实现输出操作。>>(右移)，在输入操作中与流对象cin配合使用实现输入操作。

  在C++程序中，用户不能直接用C++提供的运算符来实现用户自定义类的运算，所以用户必须根据自己的需要对C++提供的运算符进行重载，赋予他们新的含义。

二、运算符重载的方法

  运算符重载的方法是定义一个重载运算符函数，在需要执行被重载的运算符时，系统自动调用该函数。所以运算符重载实际上是函数的重载。

重载运算符的函数格式如下：

函数类型 operator 运算符名称(形参列表)

{对运算符的重载处理}

例：实现一个复数类，并重载+运算符

class Complex

{

public:

                Complex( double real =0, double imag=0) :_real(real )  //构造函数

                                , _imag( imag)

                {

                }

                 Complex operator+(Complex c2)                 //对+运算符重载，使之能进行复数相加

                {

                                 return Complex (_real+c2._real,_imag+ c2._imag);

                }

                 void display()                           //打印函数

                {

                                cout << "(" << _real << "," << _imag << "i" << ")" << endl;

                }

private:

                 double _real;

                 double _imag;

};

int main()

{

                 Complex c1(2.3,4.1);

                 Complex c2(1.4, 2.8);

                 Complex c3;

                system( "pause");

                 return 0;

}

  在上面的函数中，实现了+运算符重载，使+能够进行复数对象之间的运算。值得注意的是，运算符在被重载后，其原有的功能仍然保留。

三、运算符重载的规则

1、C++不允许用户自己定义新的运算符，只能对已有的运算符进行重载。

2、C++中不能重载的运算符只有五个，剩下的都可以重载

.(成员访问运算符)

.*(成员指针访问运算符)

::(作用域解析符)

sizeof(长度运算符)

?:(条件运算符)

3、重载不能改变运算符运算对象的个数（即操作数的个数）

4、重载不改变运算符的优先级别

5、重载不改变运算符的结合性

6、重载的运算符必须和用户自定义的自定义类型的对象一起使用，其参数至少应该有一个是类对象(或类的引用)，防止用户修改用于标准类型数据的运算符的性质，比如下面这样

int operator+(int a,int b)

{  return a-b;}

会产生二义性。

7、用于类对象的运算符一般必须重载，但有两个例外，运算符“=”和“&”不必用户重载，类默认生成的。

8、一般将单目运算符声明为类的成员函数，双目运算符声明成类的友元函数。

四、自增(++)、自减(--)运算符的重载

例：实现对复数对象实部的自增

Complex operator++(Complex& c1)         //前置自增

{  return ++c1._real;}

Complex operator++(int)(Complex& c1)    //后置自增

{  return c1._real++;}

C++中规定，后置自增的函数名要加(int)用于区分，后置自减也一样。

五、重载流插入运算符(<<)和重载流提取运算符(>>)

1、流插入运算符(<<)

例：重载流插入运算符，实现复数对象的输出

class Complex

{

public:

                Complex( double real = 0, double imag = 0) :_real(real )

                                , _imag( imag)

                {

                }

                 ostream& operator<<(ostream & os)       //“<<”的重载

                {

                                 os << "(" << _real << "," << _imag << "i" << ")" ;

                                 return os ;

                }

private:

                 double _real;

                 double _imag;

};

int main()

{

                 Complex c1(2.3, 3.5);

                c1 << cout;                             

                system( "pause");

                 return 0;

}

  请注意，上面红色的语句并没有错，这是因为重载流插入运算符函数是类成员函数，所以第一个参数是隐含的this指针。因为cout是输出流ostream类的对象。其中os就是cout。

  为了解决上面红色语句不能连续输出和不符合正常逻辑的问题，我们一般将流插入运算符重载函数声明为类的友元函数，将ostream类对象和Complex类对象进行传参：

class Complex

{

public:

                Complex( double real = 0, double imag = 0) :_real(real )

                                , _imag( imag)

                {

                }

                 friend ostream & operator<<(ostream& os, Complex& c)       //“<<”的重载

                {

                                os << "(" << c._real << "," << c._imag << "i" << ")";

                                 return os;

                }

private:

                 double _real;

                 double _imag;

};

int main()

{

                 Complex c1(2.3, 3.5);

                cout << c1 << endl;

                system( "pause");

                 return 0;

}

2、同流插入运算符重载一样，流提取运算符也是同样的道理

class Complex

{

public:

                 friend istream & operator>>(istream& is, Complex& c)       //“<<”的重载

                {

                                is >> c._real >> c._imag;

                                 return is;

                }

                 friend ostream & operator<<(ostream& os, Complex& c)       //“<<”的重载

                {

                              os << "(" << c._real << "," << c._imag << "i" << ")";

                              return os;

                }

private:

                 double _real;

                 double _imag;

};

int main()

{

                 Complex c1;

                cin >> c1;

                cout << c1 << endl;

                system( "pause");

                 return 0;

}

3、总结

istream& operator>>(istream &,自定义类 &);

ostream& operator<<(ostream &,自定义类 &);