C++浅析operator运算符重载

突然整理一下C++一些有用的知识点，防止后面自己忘了,可以马上看自己的博客能有一个很好的复习。

1.为什么要对运算符进行重载：
C++中预定义的运算符的操作对象只能是基本数据类型。但实际上，对于许多用户自定义类型（例如类），也需要类似的运算操作。这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引人的特性之一。

2.C++运算符重载的实质
运算符重载的实质就是函数重载或函数多态。运算符重载是一种形式的C++多态。目的在于让人能够用同名的函数来完成不同的基本操作。
运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进行的操作。运算符函数的定义与其他函数的定义类似，惟一的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。运算符函数定义的一般格式如下：

<返回类型说明符> operator <运算符符号>(<参数表>)  
{   
     <函数体>   
}  

3.C++运算符重载的规则

a.运算符重载不能改变该运算符用于内部类型对象的含义。它只能和用户自定义类型的对象一起使用，或者用于用户自定义类型的对象和内部类型的对象混合使用时。
这是什么意思呢？
比如说现在有两个数：int number1,int number2，
那么number1+number2 求的是两个数的和，
但是如果你重载以后让着两个数相加为他们的乘积，这肯定是不合乎逻辑的。
可能重载以后会有二义性,导致程序不知道该执行哪一个（是自带的的还是重载后的函数）

b.重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。
如不能将% 重载为一个操作数，
例如：
int index；
%index；这种是不被允许的。

c.重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。

d.除了类属关系运算符”.”、成员指针运算符”.*”、作用域运算符”::”、sizeof运算符和三目运算符”?:”以外，C++中的所有运算符都可以重载。

e. 运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。

f.大多数运算符可以通过成员函数和非成员函数进行重载但是下面这四种运算符只能通过成员函数进行重载：
= 赋值运算符，（）函数调用运算符，[ ]下标运算符，->通过指针访问类成员的运算符。

g.运算符重载是针对新类型数据的实际需要对原有运算符进行的适当的改造，重载的功能应当与原有功能相类似，避免没有目的地使用重载运算符。

运算符函数重载一般有两种形式：重载为类的成员函数和重载为类的非成员函数。非成员函数通常是友元。（可以把一个运算符作为一个非成员、非友元函数重载。但是，这样的运算符函数访问类的私有和保护成员时，必须使用类的公有接口中提供的设置数据和读取数据的函数，调用这些函数时会降低性能。可以内联这些函数以提高性能。）

4.1成员函数运算符

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

 <函数类型> operator <运算符>(<参数表>)
    {
     <函数体>
    }

当运算符重载为类的成员函数时，函数的参数个数比原来的操作数要少一个（后置单目运算符除外），这是因为成员函数用this指针隐式地访问了类的一个对象，它充当了运算符函数最左边的操作数。因此：
(1) 双目运算符重载为类的成员函数时，函数只显式说明一个参数，该形参是运算符的右操作数。

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

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

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

    <对象名>.operator <运算符>(<参数>)

它等价于

    <对象名><运算符><参数>

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

友元函数运算符
运算符重载为类的友元函数的一般格式为：

 friend <函数类型> operator <运算符>(<参数表>)
    {
     <函数体>
    }

当运算符重载为类的友元函数时，由于没有隐含的this指针，因此操作数的个数没有变化，所有的操作数都必须通过函数的形参进行传递，函数的参数与操作数自左至右一一对应。

4.2调用友元函数运算符的格式如下：

    operator <运算符>(<参数1>,<参数2>)

它等价于

    <参数1><运算符><参数2>

例如：a+b等价于operator +(a,b)。

两种重载形式的比较

　　在多数情况下，将运算符重载为类的成员函数和类的友元函数都是可以的。但成员函数运算符与友元函数运算符也具有各自的一些特点：
(1) 一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函数。

(2) 以下一些双目运算符不能重载为类的友元函数：=、()、[]、->。

(3) 类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。

(4) 若一个运算符的操作需要修改对象的状态，选择重载为成员函数较好。

(5) 若运算符所需的操作数（尤其是第一个操作数）希望有隐式类型转换，则只能选用友元函数。

(6) 当运算符函数是一个成员函数时，最左边的操作数（或者只有最左边的操作数）必须是运算符类的一　个类对象（或者是对该类对象的引用）。如果左边的操作数必须是一个不同类的对象，或者是一个内部　类型的对象，该运算符函数必须作为一个友元函数来实现。

(7) 当需要重载运算符具有可交换性时，选择重载为友元函数。

5.示例

5.1我们首先来看看单目运算符

自增运算符（++）和 自减运算符（–）都有 前置 和 后置 2中情况。

C++中为了区分前置和后置规定：前置重载与普通运算符重载一致，后置重载需要在参数列表中加入一个无用的参数（哑元）。

++/- - 的3种重载方式如下: 前置的情况可以返回类的引用,后置的情况只能返回临时对象。

#include <iostream>
using namespace std;

class CounterA
{
public:
    //默认构造函数（Default constructor）
    CounterA(){cout<<"Default Constructor"<<endl;}
    //带参数的构造函数(The constructor with parameters)
    CounterA(int m):n(m){cout<<"Parameter Constructor"<<endl;}
    //拷贝构造函数（Copy constructor）
    CounterA(const CounterA& ref){n = ref.n; cout<<"Copy Constructor"<<endl;}
    //析构函数(destructor)
    ~CounterA(){cout<<"Destructor"<<endl;}


    //重载运算符 ++（前置)
    const CounterA& operator++(){++n; return *this;}
    //重载运算符 ++（后置）
    const CounterA operator++(int dump){CounterA Tmp(*this);++n; return Tmp;}
    //重载运算符 --（前置）
    const CounterA& operator--(){--n; return *this;}
    //重载运算符 --（后置）
    const CounterA operator--(int dump){CounterA Tmp(*this);--n; return Tmp;}

    //输出用函数
    void display(void){cout<<"n = " << n << endl;}
    //GetData
    int GetVal(void){return n;}

private:
    int n;
};

class CounterB
{
public:
    //默认构造函数（Default constructor）
    CounterB(){cout<<"Default Constructor"<<endl;}
    //带参数的构造函数(The constructor with parameters)
    CounterB(int m):n(m){cout<<"Parameter Constructor"<<endl;}
    //拷贝构造函数（Copy constructor）
    CounterB(const CounterB& ref){n = ref.n; cout<<"Copy Constructor"<<endl;}
    //析构函数(destructor)
    ~CounterB(){cout<<"Destructor"<<endl;}

    //重载运算符 ++（前置)
    friend const CounterB& operator++(CounterB& ref){ref.n += 1;return ref;}
    //重载运算符 ++（后置）
    friend const CounterB operator++(CounterB& ref, int dump){CounterB Tmp(ref);ref.n += 1; return Tmp;}
    //重载运算符 --（前置）
    friend const CounterB& operator--(CounterB& ref){ref.n -= 1;return ref;}
    //重载运算符 --（后置）
    friend const CounterB operator--(CounterB& ref, int dump){CounterB Tmp(ref);ref.n -= 1; return Tmp;}

    //输出用函数
    void display(void){cout<<"n = " << n << endl;}
    //GetData
    int GetVal(void){return n;}
    //SetData
    void SetVal(int val){n = val;}

private:
    int n;
};

class CounterC
{
public:
    //默认构造函数（Default constructor）
    CounterC(){cout<<"Default Constructor"<<endl;}
    //带参数的构造函数(The constructor with parameters)
    CounterC(int m):n(m){cout<<"Parameter Constructor"<<endl;}
    //拷贝构造函数（Copy constructor）
    CounterC(const CounterC& ref){n = ref.n; cout<<"Copy Constructor"<<endl;}
    //析构函数(destructor)
    ~CounterC(){cout<<"Destructor"<<endl;}


    //输出用函数
    void display(void){cout<<"n = " << n << endl;}
    //GetData
    int GetVal(void){return n;}
    //SetData
    void SetVal(int val){n = val;}

private:
    int n;
};
//重载运算符 ++（前置)
const CounterC& operator++(CounterC& ref){ref.SetVal(ref.GetVal()+1);return ref;}
//重载运算符 ++（后置）
const CounterC operator++(CounterC& ref, int dump){CounterC Tmp(ref);ref.SetVal(ref.GetVal()+1); return Tmp;}
//重载运算符 --（前置）
const CounterC& operator--(CounterC& ref){ref.SetVal(ref.GetVal()-1);return ref;}
//重载运算符 --（后置）
const CounterC operator--(CounterC& ref, int dump){CounterC Tmp(ref);ref.SetVal(ref.GetVal()-1); return Tmp;}


int main(void)
{
    CounterA cp1(5);cp1.display();
    ++cp1;cp1.display();
    --cp1;cp1.display();
    CounterA cp2(cp1++);cp2.display();
    CounterA cp3(cp1--);cp3.display();

    CounterB cp4(5);cp4.display();
    ++cp4;cp4.display();
    --cp4;cp4.display();
    CounterB cp5(cp4++);cp5.display();
    CounterB cp6(cp4--);cp6.display();

    CounterC cp7(5);cp7.display();
    ++cp7;cp7.display();
    --cp7;cp7.display();
    CounterC cp8(cp7++);cp8.display();
    CounterC cp9(cp7--);cp9.display();

    return 0;
}

还有示例见http://blog.csdn.net/maoliran/article/details/51583165
完整的事例：http://blog.csdn.net/lishuzhai/article/details/50781753
有详细的解释，代码我就不贴过来了

5.2重载<<和>>操作符示例

#include <iostream>
using namespace std;

class Complex
{
private:
    int real, imag;
public:
    Complex(int r = 0, int i =0)
    {  real = r;   imag = i; }
    friend ostream & operator << (ostream &out, const Complex &c);
    friend istream & operator >> (istream &in,  Complex &c);
};

ostream & operator << (ostream &out, const Complex &c)
{
    out << c.real;
    out << "+i" << c.imag << endl;
    return out;
}

istream & operator >> (istream &in,  Complex &c)
{
    cout << "Enter Real Part ";
    in >> c.real;
    cout << "Enter Imaginary Part ";
    in >> c.imag;
    return in;
}

int main()
{
   Complex c1;
   cin >> c1;
   cout << "The complex object is ";
   cout << c1;
   return 0;
}

输出如下：

经典博主：
1.http://blog.csdn.net/zgl_dm/article/details/1767201

2.http://blog.csdn.net/lishuzhai/article/details/50781753

3.http://blog.csdn.net/lwb102063/article/details/51863510

4.http://blog.csdn.net/shltsh/article/details/46039189

还有很多博主写得不错，大家多分享交流。

这个要不断的多加练习才能熟练，先到这吧！