运算符重载（C++）1

面向对象程序设计的特点：抽象，封装，继承，多态。
A) 抽象是指对具体问题 （对象）进行概括，抽出一类对象的公共性质并加以描述的过程。一个问题的抽象应包括数据抽象（描述某类对象的性质或状态）和行为抽象（某类对象的共同行为或功能特征）。
比如时钟类的抽象：
数据抽象： int hour, int minute, int second
功能抽象：showTime(), setTime()
B) 封装：就是将抽象得到的数据和行为相结合，形成一个有机体 ，也就是将数据与操作数据的函数代码进行有机的结合，形成“类”，其中的数据和函数都是类的成员。
C） 继承 可以将特殊与一般的概念描述清楚，并且使得特殊概念之间既能共享一般的属性和行为，又能具有特殊的属性和行为。
D）多态性：是指一段程序能够处理多种类型对象的能力，它包含强制多态、重载多态、类型参数化多态、包含多态四种。

重载多态又包含函数重载与运算符重载。先来看看运算符重载：
一、
运算符重载是对已有的运算符 赋予多重含义，是同一个运算符作用于不同数据类型的数据时导致不同的行为。运算符重载实质上就是函数重载。在实现的过程中，首先把指定的运算表达式转化为对运算符函数的调用，将运算对象转化为运算符的函数的实参，然后根据实参的类型来确定需要调用的函数。
二、 运算符重载的规则：
1. C++中的运算符除了少数的几个之外，全部可以重载，而且只能重载C++中已有的运算符。
2. 重载之后运算符的优先级和结合性都不会改变。
3. 运算符重载是针对新类型数据的需要，对原有运算符进行适当的改造。重载的功能应当与原有的功能相似，不能改变原运算符的操作对象个数，同时至少有一个操作对象是自定义类型。
4. C++标准规定，类属关系运算符“.”，成员指针运算符“.*”，作用域分辨符“：：”和三目运算符”?:” ，这些都是不能重载的。
三、运算符重载的形式有两种：即重载为类的成员函数和重载为友元函数。运算符重载的一般语法形式为：
返回类型 operator 运算符 （形参表）
{
函数体
}
友元函数的形式：
返回值类型 operator 运算符 （类名 &对象名，类名 &对象名）
成员函数的形式：
返回值类型 operator 运算符 （类名 &对象名）

返回值类型可以是值类型也可以是引用返回，确定好返回值类型就会变得很重要。表达式如果不能放在左边，就是值返回； 如果能放在右边既可以值返回也还可以引用返回，但是加法的引用返回会改变原来的值，所以加法的返回应该用值返回。下面以加法运算符的重载的例子说明这一点：

class A
{
public:
    A (int i=0):m_i(i){}
    friend A sum(A &b, A &c);
    A sum(A &b)  
    {
        return m_i + b.m_i;   //非静态函数中含有this指针，所以这里的m_i是this指向的m_i即调用该函数的对象的m_i
    }   
    A operator +(A &b)   //+运算符重载为成员函数  值返回
    {
        return m_i + b.m_i;
    }
    void print()
    {
        cout<A sum(A &b, A &c)   
{
    return b.m_i + c.m_i;
}
void main()
{
    A a(2), b(7);
    A c = sum(a,b);  
    c.print();

    A d = a.sum(b); 
    d.print();

    A e = a + b;
    e.print();
    a.print();
}

这是给出值返回的重载函数，下面看看运行结果：

可以看到最后输出a的值是2；
当利用引用返回时：

A &operator+(A &b)
    {
        m_i = m_i + b.m_i;
        return *this;
    }

会看到输出结果中a的值被改变了：

会明显看到a的值变为了a与a+b运算后的结果相同。
所以，一般的加法运算的重载应该设为值返回。

接下来看看++运算符的重载：
前++重载函数形式：
返回值类型 operator ++（int）<这里的int没有任何含义，仅仅是为了说明这是后++的重载>
后++重载函数形式：
返回值类型 operator ++（）

class A
{
public:
    A (int i=0):m_i(i){}
    A operator++(int)   //后++重载
    {
        return m_i++;
    }
    A operator++()   //前++重载
    {
        return ++m_i;
    }
    void print()
    {
        cout<private:
    int m_i;
};
void main()
{
    A a(3);
    (a++).print();
    (++a).print();
}

下来看看运行结果：

根据（++a）打印出的结果5可以得出执行完（a++）后a的值变为了4。
前++的引用返回重载函数如下：

A &operator ++()
    {
        ++m_i;
        return *this;
    }

接下来看看赋值运算符的重载：

class A
{
public:
    A (int i=0):m_i(i){}
    A &operator=(A &b)
    {
        m_i = b.m_i;
        return *this;
    }
    void print()
    {
        cout<private:
    int m_i;
};

void main()
{
    A a(3);
    a.print();
    A b = a;
    b.print();
}

运行结果如下：

输出运算符的重载：
输出运算符是双目运算符，out是ostream类的对象。代码如下:

class A
{
public:
    A (int i=0):m_i(i){}
    friend ostream& operator<<(ostream &out, A &a);
    void print()
    {
        cout<private:
    int m_i;
};
ostream &operator<<(ostream &out,A &a)
{
    out<return out;
}
void main()
{
    A a(3);
    cout<<"a= "<

运行结果如下：

剩下的运算符重载将会在后面给出。