C++中的操作符重载

转自：http://www.cnblogs.com/BeyondAnyTime/archive/2012/09/01/2666570.html

一、什么是操作符重载

操作符重载可以分为两部分：“操作符”和“重载”。说到重载想必都不陌生了吧，这是一种编译时多态，重载实际上可以分为函数重载和操作符重载。运算符重载和函数重载的不同之处在于操作符重载重载的一定是操作符。我们不妨先直观的看一下所谓的操作符重载：

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 int main()
 6 {
 7     int a = 2 , b = 3;
 8     float c = 2.1f , d = 1.2f;
 9     cout<<"a + b = "<<a+b<<endl;
10     cout<<"c + d = "<<c+d<<endl;
11     return 0;
12 }

我们看到操作符“+”完成float和int两种类型的加法计算，这就是操作符重载了。这些内置类型的操作符重载已经实现过了，但是如果现在我们自己写过的类也要实现实现类似的加法运算，怎么办呢？？比如现在现在有这样一个点类point，要实现两个点的相加，结果是横纵坐标都要相加，这时候就需要我们自己写一个操作符重载函数了。

View Code

 

二、实现操作符重载的两种方式

操作符重载的实现方式有两种，即通过“友元函数”或者“类成员函数”。

1.友元函数重载操作符的格式:

1 class 类名
2 {
3     friend 返回类型 operator 操作符(形参表);
4 };
5 //类外定义格式：
6 返回类型 operator操作符(参数表)
7 {
8     //函数体
9 }

2.类成员函数实现操作符重载的格式：

 1 class 类名
 2 {
 3 public:
 4     返回类型 operator 操作符(形参表)；
 5 };
 6 //类外定义格式
 7 返回类型 类名::operator 操作符(形参表)
 8 {
 9     //函数体
10 }

这样说吧，还是不足以比较这两种实现方式的区别，我们分别用两种实现方式写point类的”+“和”-“的重载。代码如下：

 1 #include <iostream>
 2 
 3 using std::endl;
 4 using std::cout;
 5 
 6 class point
 7 {    
 8     double x;
 9     double y;
10 public:
11     double get_x()
12     {
13         return x;
14     }
15     double get_y()
16     {
17         return y;
18     }
19     point(double X = 0.0 , double Y = 0.0):x(X),y(Y){};
20     friend point operator -(point p1,point p2);
21     point operator +(point p);
22 };
23 //重载操作符“-”
24 point operator -(point p1,point p2)
25 {
26     double x = p1.get_x() - p2.get_x();
27     double y = p1.get_y() - p2.get_y();
28     point p3(x,y);
29     return p3;
30 }
31 //重载操作符“+”
32 point point::operator +(point p)
33 {
34     double x = this->x + p.x;
35     double y = this->y + p.y;
36     point tmp_p(x,y);
37     return tmp_p;
38 }
39 int main()
40 {
41     point p1(1.2,3.2);
42     point p2(1.1,3.1);
43     point p3 = p1+p2;
44     point p4 = operator-(p1,p2);
45     cout<<p3.get_x()<<" "<<p3.get_y()<<endl;
46     cout<<p4.get_x()<<" "<<p4.get_y()<<endl;
47     return 0;
48 }

这里不知道大家看到没有，利用友元函数重载二元操作符”-“时，形式参数是两个，而利用类成员函数时，形式参数却只有一个。这时因为类成员函数中存在this指针，这相当于一个参数，所以类成员实现操作符重载需要的形式参数比原来少一个，这比如：利用类成员函数实现一元操作符”-“，就不需要参数了。也正是因为这个原因，友元函数实现的操作符重载是有限制的，比如：[] ，（），->和 =不能利用友元函数实现运算符的重载。

在实际开发过程中，单目运算符建议重载为成员函数，而双目运算符建议重载为友元函数。通常下双目运算符重载为友元函数比重载为成员函数更方便，但是有时双目运算符必须重载为成员函数，例如赋值运算符=。还有如果需要修改对象内部的状态，一般可以选择利用类成员函数进行修改。

 

三、运算符重载的原则

这样一看，运算符重载还是蛮简单的嘛，实际上运算符重载也是要遵循一些原则的：

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

2.C++中绝大部分的运算符可重载，除了成员访问运算符^.，作用域运算符::，长度运算符sizeof以及条件运算符?:。

3.运算符重载后不能改变运算符的操作对象(操作数)的个数。如："+"是实现两个操作数的运算符，重载后仍然为双目运算符。

4.重载不能改变运算符原有的优先级和原有的结合性。

6.运算符重载不能全部是C++中预定义的基本数据，这样做的目的是为了防止用户修改用于基本类型数据的运算符性质。

 

四、为什么要进行运算符重载

关于运算符重载要遵循这么多原则，那么为什么还要进行运算符重载呢？为什么我不是写一个add()函数，代替operator +()呢？？个人感觉C++中之所以要支持运算符的重载是为了与内置数据类型统一操作，比如：c = a + b 和 c = add（a,b），这看起来哪个更直观一点呢，显然是前者了。同时，我们希望操作我们自己定义的数据类型能像操作int和double这些内置数据类型一样方便。可能举这个加法的例子有点不好，现在加入重载的运算符是[],<<,^,|等呢？这时我们要用什么成员函数代替呢？？代替之后又是一种什么效果呢？会一眼就看出来这个函数要干什么吗？？

思考：C++中的++运算符是有两种的，这个我们怎么区别重载的是前自增还是后自增呢？

很久以前（八十年代），没有办法区分++和--操作符的前缀与后缀调用。这个问题遭到程序员的报怨，于是C++语言得到了扩展，允许重载 increment 和 decrement操作符的两种形式。然而有一个句法上的问题，重载函数间的区别决定于它们的参数类型上的差异，但是不论是increment或decrement的前缀还是后缀都只有一个参数。为了解决这个语言问题，C++规定后缀形式有一个int类型参数，当函数被调用时，编译器传递一个0做为int参数的值给该函数。

increment的前缀形式表示“增加然后取回”，后缀形式表示“取回然后增加”。

 

Sample code:

[cpp]  view plain copy

1. #include "stdafx.h"   
2. #include "assert.h"   
3. class  A   
4. {   
5. public :   
6.     A( int  i)   
7.         :m_i(i)   
8.     {   
9.     }   
10.      // ++i   
11.     A& operator++()   
12.     {   
13.         ++m_i;   
14.          return  * this ;   
15.     }   
16.      // i++   
17.      const  A operator++( int )   
18.     {   
19.         A tmp = * this ;   
20.         ++(* this );     // Implemented by prefix increment   
21.          return  A(tmp);   
22.     }   
23.      int  m_i;   
24. };   
25. int  _tmain( int  argc, _TCHAR* argv[])   
26. {   
27.      int  i = 0;   
28.      int  i1 = i++;    // i1 = 0; i = 1;   
29.      int  i2 = ++i;    // i2 = 2; i = 1;   
30.     A a(0);   
31.     A a1 = a++;      // i1 = 0; i = 1;   
32.     A a2 = ++a;      // i2 = 2; i = 1;   
33.        
34.      //a++++; //avoid   
35.      //++++a; //support   
36.     assert(i1 == a1.m_i);   
37.     assert(i2 == a2.m_i);   
38.      return  0;   
39. }   

 

说明

1. 类中的++操作符号重载之后必须保证其语意与全局++相同。

2.为了区分前后，用++()表示前自增，用++(int)后自增。

3.因为按照前自增的标准定义,应该支持"++++a"的语法,而且两次前自增都应该是对a对象的自身操作,如果返回A类型,那第二次前自增调用的是临时对象的前自增操作。
4.后自增应该返回"const Complex".这可以防止形如"a++++"的用法。

5.一般通过前自增操作来实现后自增操作符函数。

参考：http://blog.csdn.net/ccbird88/article/details/6014518