运算符重载

运算符重载的目的就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。

在C++ 预定义的运算符中，它们只适用于基本数据类型。但是对于我们经常会自己定义一些数据类型（类），我们也同样希望它们可以进行类似的操作，这时候我们就需要对运算符进行重载。运算符重载的实质其实是函数重载，它是C++最吸引人的特性之一。

1.运算符重载的定义：

运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进行的操作。运算符函数的定义与其他函数的定义类似，惟一的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。

2.运算符重载时要遵循以下规则：
(1) 除了类属关系运算符"."、成员指针运算符"*"、作用域运算符"::"、sizeof运算符和三目运算符"?:"、编译预处理命令的开始符号“#”以外，C++中的所有运算符都可以重载。
(2) 重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。
(3) 运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。
(4) 重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。
(5) 运算符重载不能改变该运算符用于内部类型对象的含义。它只能和用户自定义类型的对象一起使用，或者用于用户自定义类型的对象和内部类型的对象混合使用时。
(6) 运算符重载是针对新类型数据的实际需要对原有运算符进行的适当的改造，重载的功能应当与原有功能相类似，避免没有目的地使用重载运算符。
     （7）重载运算符的函数不能有默认的参数，否则就改变了运算符的参数个数，与前面第3点相矛盾了；
     （8）重载的运算符只能是用户自定义类型，否则就不是重载而是改变了现有的C++标准数据类型的运算符的规则了，会引会天下大乱的；
     （9）用户自定义类的运算符一般都必须重载后方可使用，但两个例外，运算符“=”和“&”不必用户重载；
     （10）运算符重载可以通过成员函数的形式，也可是通过友元函数，非成员非友元的普通函数。

3重载的建议

当C++语言原有的一个运算符被重载之后，他原来所具有的语义并没有消失，只相当于针对一个特定的类定义了一个新

的运算符。

运算符可以使用成员函数和友元函数两种形式。可以参考以下的经验：

（1）只能使用成员函数重载的运算符有：=、()、[ ]、->、new、delete。

（2）单目运算符最好重载为成员函数。

（3）对于符合的复制运算符如+=、-=、*=、/=、&=、！=、~=、%=、>>=、<<=建议重载为成员函数。

（4）对于其他运算符，建议重载为友元函数。

（5）不建议重载的运算符如：, 、 & 、&& 、 || 。

4重载的形式

运算符函数重载一般有两种形式：重载为类的成员函数和重载为类的非成员函数。非成员函数通常是友元函数。（可以

把一个运算符作为一个非成员、非有原函数重载。但是这样的运算符函数访问类的私有和保护成员时，必须试用

类的共有接口提供的设置数据和读取数据的函数，调用这些函数时会降低性能。可用过内联这些函数以提高性能。）

1）成员函数运算符

运算符重载为类的成员函数一般格式为：

<函数类型> operator <运算符> （<参数表>）

{

<函数体>

}

当运算符重载为类的成员函数时，函数的参数个数比原来的操作数要少一个（后置单目运算符除外），这是因为成员函数

用this指针隐式的访问了类的一个对象，他充当了运算符函数最左边的操作数。所以

（1）双目运算符重载为类的成员函数时，函数值显示说明一个参数，该行蚕食运算符的右操作数。

（2）前置单目运算符重载为类的成员函数时，不需要显示说明参数，即函数没有形参。

（3）后置单目运算符重载为类的成员函数时，函数要带有一个整形参数。

调用成员函数运算符的格式如下：

<对象名>.operator <运算符>(<参数>) 它等价于<对象名><运算符><参数>

例如：a+b 等价于a.operator + (b) 。一般情况下，我们采用运算符的习惯表达式。

接下来写个例子看一下：

#include<iostream>
using namespace std;
class Point
{
private:
    int xx, yy;
public:
    Point()
    {
        xx=0, yy = 0;
    }
    Point(int a, int b)
    {
        xx = a, yy = b;
    }
    ~Point(){}
    Point operator+(Point &a)
    {
        Point c;
        c.xx = xx + a.xx;
        c.yy = yy + a.yy;
        return c;
    }
    int x()
    {
        return this->xx;
    }
    int y()
    {
        return this->yy;
    }
};
int main()
{
    Point a(1,2), b(2,3), c;
    c = a + b;
    cout << "a = (" << a.x() << " ," << a.y() << ")" << endl;
    cout << "b = (" << b.x() << " ," << b.y() << ")" << endl;
    cout << "c = (" << c.x() << " ," << c.y() << ")" << endl;

    return 0;
}

这样就实现了将我定义的类Point中的点相加的目的

2） 友元函数运算符
　 运算符重载为类的友元函数的一般格式为：
    friend <函数类型> operator <运算符>(<参数表>)
    {
     <函数体>
    }
当运算符重载为类的友元函数时，由于没有隐含的this指针，因此操作数的个数没有变化，所有的操作数都

必须通过函数的形参进行传递，函数的参数与操作数自左至右一一对应。
　 调用友元函数运算符的格式如下：
    operator <运算符>(<参数1>,<参数2>) 它等价于 <参数1><运算符><参数2>
    例如：a+b等价于operator +(a,b)。

同样我们写一个例子来看一下：

#include<iostream>
using namespace std;
class Point
{
private:
    int xx, yy;
public:
    Point()
    {
        xx = yy = 0;
    }
    Point(int x, int y)
    {
        xx = x, yy = y;
    }
    ~Point(){}
    friend Point operator+(const Point &a, const Point &b)
    {
        Point c;
        c.xx = a.xx + b.xx;
        c.yy = a.yy + b.yy;
        return c;
    }
    int x()
    {
        return this->xx;
    }
    int y()
    {
        return this->yy;
    }
};
int main(){
   Point a(1,2), b(2,3), c;
   c = a + b;
   cout << "a = (" << a.x() << ", " << a.y() << ")" << endl;
   cout << "b = (" << b.x() << ", " << b.y() << ")" << endl;
   cout << "c = (" << c.x() << ", " << c.y() << ")" << endl;

   return 0;
}

可能大家看到这里会问，那么这两个例子都是实现了讲定义的Point类的两个点相加，那么通过成员函数和通过友元函数来进行重载到底有什么不同，下面我给这两种方法的 比较 ：

在多数情况下，将运算符重载为类的成员函数和类的友元函数都是可以的。但成员函数运算符与友元函数运算符也具有

各自的一些特点：
(1) 一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函数。
(2) 以下一些双目运算符不能重载为类的友元函数：=、()、[]、->。
(3) 类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。
(4) 若一个运算符的操作需要修改对象的状态，选择重载为成员函数较好。
(5) 若运算符所需的操作数（尤其是第一个操作数）希望有隐式类型转换，则只能选用友元函数。
(6) 当运算符函数是一个成员函数时，最左边的操作数（或者只有最左边的操作数）必须是运算符类的一个

类对象（或者是对该类对象的引用）。如果左边的操作数必须是一个不同类的对象，或者是一个内部类型

的对象，该运算符函数必须作为一个友元函数来实现。
(7) 当需要重载运算符具有可交换性时，选择重载为友元函数。