运算符重载

一, 运算符重载的意义
    C++ 允许我们重定义操作符用于类类型对象时的含义。如果需要，可以像内置转换那样使用类类型转换，将一个类型的对象隐式转换到另一类型。
    通过操作符重载，可以重定义大多数操作符，使它们用于类类型对象。明智地使用操作符重载可以使类类型的使用像内置类型一样直观。允许程序使用表达式而不是命名函数，可以使编写和阅读程序容易得多。将     

cout << "The sum of " << v1 << " and " << v2 << " is " << v1 + v2 << endl;

 和以下更为冗长的代码相比较就能够看到。如果 IO 使用命名函数，类似下面的代码将无法避免：      

// hypothetical expression if IO used named functions
cout.print("The sum of ").print(v1).
     print(" and ").print(v2).print(" is ").
     print(v1 + v2).print("\n").flush();

二, 运算符重载的规则
    1.  C++中的运算符除了以下四个之外，全部可以重载，而且只能重载C++中已有的运算符, 不能重载的运算符只有五个: 成员运算符“.”、指针运算符“*”、作用域运算符“：：”、“sizeof”、条件运算符“？：”
    2. 重载之后的优先级和结合性不会改变;
    3. 通过连接其他合法符号可以创建新的操作符。例如，定义一个 operator** 以提供求幂运算是合法的. 另外, 重载操作符必须具有一个类类型操作数. 例如，内置的整型加号操作符不能重定义： 
        int operator+(int, int);//非法
三, 运算符重载形式有两种，重载为类的成员函数和重载为类的友元函数。 
    1. 运算符重载为类的成员函数的一般语法形式为： 
    函数类型 operator 运算符（形参表） 
    { 
        函数体； 
    } 
    2. 运算符重载为类的友元函数的一般语法形式为： 
    friend 函数类型 operator 运算符（形参表） 
    { 
         函数体； 
    } 
    其中，函数类型就是运算结果类型；operator是定义运算符重载函数的关键字；运算符是重载的运算符名称。 当运算符重载为类的成员函数时，函数的参数个数比原来的操作个数要少一个；当重载为类的友元函数时，参数个数与原操作数个数相同。原因是重载为类的成员函数时，如果某个对象使用重载了的成员函数，自身的数据可以直接访问，就不需要再放在参数表中进行传递，少了的操作数就是该对象本身。而重载为友元函数时，友元函数对某个对象的数据进行操作，就必须通过该对象的名称来进行，因此使用到的参数都要进行传递，操作数的个数就不会有变化。 
运算符重载的主要优点就是允许改变使用于系统内部的运算符的操作方式，以适应用户自定义类型的类似运算.

四, 举一个关于给复数运算重载复数的四则运算符的例子。复数由实部和虚部构造，可以定义一个复数类，然后再在类中重载复数四则运算的运算符。先看以下源代码    

#include <iostream>

using namespace std;

class complex
{
public:
    complex() : m_dReal(0),    m_dImag(0){}
    complex(double r, double i) : m_dReal(r), m_dImag(i){}

    inline complex operator +(const complex &c);
    inline complex operator -(const complex &c);
    inline complex operator *(const complex &c);
    inline complex operator /(const complex &c);
    friend inline ostream& operator<<(ostream& os, const complex &c);

private:
    double    m_dReal;
    double    m_dImag;
};

inline complex complex::operator +(const complex &c)
{
    return complex(m_dReal + c.m_dReal, m_dImag + c.m_dImag);
}

inline complex complex::operator -(const complex &c)
{
    return complex(m_dReal - c.m_dReal, m_dImag - c.m_dImag);
}

inline complex complex::operator *(const complex &c)
{
    return complex(m_dReal * c.m_dReal - m_dImag * c.m_dImag, m_dReal * c.m_dImag + m_dImag * c.m_dReal);
}

inline complex complex::operator /(const complex &c)
{
    return complex((m_dReal * c.m_dReal + m_dImag + c.m_dImag) / (c.m_dReal * c.m_dReal + c.m_dImag * c.m_dImag),
        (m_dImag * c.m_dReal - m_dReal * c.m_dImag) / (c.m_dReal * c.m_dReal + c.m_dImag * c.m_dImag));
}

inline ostream& operator<<(ostream& os, const complex &c)
{
    if(c.m_dImag < 0)
        os << c.m_dReal << c.m_dImag << 'i';
    else
        os << c.m_dReal << '+' <<c.m_dImag <<'i';
    os << endl;

    return os;
}

void main()
{
    complex c1(2.0, 3.0), c2(4.0, -2.0), c3;
    c3 = c1 + c2;
    cout<<"c1+c2=" << c3;

    c3 = c1 - c2;
    cout<<"c1-c2=" << c3;

    c3 = c1 * c2;
    cout<<"c1*c2=" << c3;

    c3 = c1 / c2;
    cout<<"c1/c2=" << c3;

    c3 = (c1+c2) * (c1-c2) * c2/c1;
    cout<<"(c1+c2)*(c1-c2)*c2/c1=" << c3;
}

输出如下: 
c1+c2=6+1i
c1-c2=-2+5i
c1*c2=14+8i
c1/c2=0.45+0.8i
(c1+c2)*(c1-c2)*c2/c1=9.61538+25.2308i

说明:
    1. 重载为成员函数, 将运算符重载函数说明为类的成员函数格式如下：

    ＜类名＞ operator ＜运算符＞(＜参数表＞)

    其中，operator是定义运算符重载函数的关键字。

    程序中出现的表达式：

            c1+c2

     编译程序将给解释为：
        c1.operator+(c2)

    其中，c1和c2是complex类的对象。operator+()是运算+的重载函数。该运算符重载函数仅有一个参数c2。可见，当重载为成员函数时，双目运算符仅有一个参数。对单目运算符，重载为成员函数时，不能再显式说明参数。重载为成员函数时，总时隐含了一个参数，该参数是this指针。this指针是指向调用该成员函数对象的指针。 

    2. 重载为友元函数, 的运算符重载函数的定义格式如下： 

    friend ＜类型说明符＞ operator ＜运算符＞(＜参数表＞)
    当重载友元函数时，将没有隐含的参数this指针。这样，对双目运算符，友元函数有2个参数，对单目运算符，友元函数有一个参数。但是，有些运行符不能重载为友元函数，它们是：=,(),[]和->