废话不多说，这次讲的是 Operator overload. 关于operator, 在 < The C++ Programing Language > 里的描述，可以用做overload的如下：
+ * / % ^ & | ~ ! = < > += = *= /= %= ^= &= |= << >> >>= <<= == != <=
>= && || ++ >* , > [] () new new[] delete delete[]
先从 operator = 说起。上章中Aear已经提到过，这里再次强调下，只要是在class member中有 pointer的存在，class 就应该提供 copy constructor 和 operator =.
除了 operator =以外，最常用的operator就是 + - * / += -+ *= /= ++ --。 由于四则运算大同小异，我们就拿简单的 + 来举例子说明。让我们看下下面的这段代码有什么问题：
class Test {
private:
int internalData;
public:
// constructor and destructor
Test(int data = 0) : internalData(data) {};
Test(const Test & Para) : internalData(Para.internalData) {};
~Test() {};
// Operator overlording
Test & operator += (const Test & Para1);
Test operator + (const Test & Para1);
};
Test & Test::operator += ( const Test & Para1 )
{
internalData += Para1.internalData;
return * this;
}
Test Test::operator + (const Test & Para1)
{
Test result;
result.internalData = internalData + Para1.internalData;
return result;
}
首先让我们比较一下 += 和 + 两个operator的效率，我们可以看到，在"+="中，返回的是 *this的reference,而在+中，返回的是一个临时创建的 result，并且 result object在返回的过程中，由于是return by value，因此compiler会掉用copy constructor把result拷贝到返回值中，然后掉用 result.~test()销毁掉这个临时变量。也就是说，使用 + 比 += 要产生更多的overhead。在某些效率第一的情况下，临时变量的constructor和destructor都是非常昂贵的操作。比如：
=============one temporary object=============
Test x1 = x2 + x3;
为了提高效率，我们可以这么写：
=============no temporary object=============
Test x1(x2);
x1 += x3;
简单一点的表达式有可能会被compiler优化掉，但是复杂的表达式，只能才用手动的形式优化。
让我们再仔细的看下 Test Test::operator + (const Test & Para1) 这个函数。如果考虑程序的具体实现，我们可以看出来 operator += 和 operator +没有本质的却别，但是如果我们需要改动 Test + 的操作，就必须同时更改 operator += 和 operator + 实现，对同一种功能在几处不同的地方进行维护，并不是良好的设计，因此，我们应该对 Test Test::operator + (const Test & Para1) 做如下改动，使得程序更加容易维护：
=============easy to maintain=============
Test Test::operator + (const Test & Para1)
{
Test result(*this);
result += Para1;
return result;
}
可以看到在operator +里调用了 +=的操作，因此，如果我们需要给加法赋予不同的含义，只需要更改 operator += 就足够了。
让我们继续深入的看 Test Test::operator + (const Test & Para1)。值得强调的是，无论如何temporary object是必须存在的，无数大师的经验证明，想用static member, dynamic memory等方法消除掉 temporary object 的 construction 和 destruction,都会产生这样或者那样的逻辑和程序错误。
但是我们仍然可以利用compiler来对这个temporary object进行优化。对于Test Test::operator + (const Test & Para1) 这样的操作，compiler会传递给 operator + 一个 temporary object, 如果 operator +里的代码合适，那么compiler就会用这个temporary object 代替程序里创建的temporary object,从而减少了constructor和destructor的掉用。经过compiler优化后的pseudocode如下：
Test::operator + (Test & Temporary, const Test & Para1)
{
Temporary.internalData = internalData + Para1.internalData;
return;
}
这样减少了temporary object 的construction 和 destruction，效率就会提高很多，但是要想使compiler能够进行 return by value的优化，必须满足2个条件：
1. class 必须有 copy constructor
2. 在代码中明确表示，返回的是个temporary object.
因此，出了提供copy constructor外，还必须对 operator + 进行适当的修改，最终代码如下：
==========Final Version for Maintenance and Optimization==========
Test Test::operator + (const Test & Para1)
{
return Test(*this) += Para1;
}
在这个代码里边，最明显的区别就是没有result这个变量，而是返回一个临时创建的Test object,因此compiler就会知道这个函数可以用临时变量优化。
也许你会感到惊讶，不过这个operator +还不是最快速的。因为我们看到，在Test(*this) += Para1 的过程中，调用了一次constructor 一次 operator +=，但是已经足够了。不过为了效率，我们有更加极端的方法，在如下的代码中，我们舍弃了可读性，可维护性等等，只为了更快的速度：
==========糟糕的风格，不过更快==========
class Test {
...
private:
// cosntructor for operator +
Test(int data, const Test & Para1 ) : internalData(data + Para1.internalData) {};
};
Test Test::operator + (const Test & Para1)
{
return Test(internalData, Para1);
}
如果同时还要定义 operator - * /等操作的constructor，我们可以适当更改constructor的signature，从而可以用constructor实现不同的运算
关于operator第一部分今天就说这么多，大家有空去坐坐 http://blog.sina.com.cn/u/1261532101 ;下次见。
======================================================
大家请把我的文章当参考，详细内容 还请参照 权威书籍
<c++ programming language>如果文中有错误和遗漏，
请指出，Aear会尽力更正, 谢谢！
======================================================
继续上一章的内容，下面是经过调整后的Test Class代码：
class Test {
private:
int internalData;
public:
// constructor and destructor
Test(int data = 0) : internalData(data) {};
Test(const Test & Para) : internalData(Para.internalData) {};
~Test() {};
// Operator overlording
Test & operator += (const Test & Para1);
Test operator + (const Test & Para1);
};
Test & Test::operator += ( const Test & Para1 )
{
internalData += Para1.internalData;
return * this;
}
Test Test::operator + (const Test & Para1)
{
return Test(*this) += Para1;
}
下面我们假设要给这个Test Class添加一种新的功能，让Test Class 和 Integer之间能够进行加法操作。 也就是说可以执行下列代码:
Test x1(10);
x1 = x1 + 5;
x1 += 5;
实际上，我们不需要进行任何修改，上面的代码就能够正确执行。因为我们提供的构造函数Test(int data = 0) 能够隐性的 (implicit type conversion) 把一个integer 转换成一个Temporary Test Object，然后掉用 Test Test::operator + (const Test & Para1)。因此，上面的代码等同于：
x1 = x1.operator + (Test(5));
x1 = x1.operator += (Test(5));
Implicit Type Conversion 实际上会带来很多的麻烦，要想避免潜在的危险，最好在Test(int data = 0)前面加上explicit，表示如果对interger转换成Test，必须由程序员来控制，compiler不得进行隐性的操作。因此，要想似的 x1 = x1 + 5能够正常运行，有2种方法：
x1 = x1 + static_cast<Test>(5);
或
x1 = x1 + Test(5);
还有一点需要注意的是，如果不用explicit type conversion,可以运行:
x1 = x1 + 5;
但是在编译：
x1 = 5 + x1
的时候就会报错了，除非使用一个Temporary Object ，如：
x1 = Test(5) + x1;
要想使Test Class 支持 x1 = 5 + x1，最好的方法就是用helper function. 下面我们来看看Operator的另外一中定义方式。
==================分割线==================
我们可以使用friend function 来定义Test Class 的加法运算，代码如下：
class Test {
Test(int data = 0) : internalData(data) {};
...
// 针对这个Test Class, 并不需要下面这行。
friend Test operator + ( const Test & Para1, const Test & Para2);
};
Test operator + ( const Test & Para1, const Test & Para2)
{
return Test(Para1) += Para2;
}
首先我们需要注意的是，Test(int data = 0)没有用explicit,也就是说可以进行隐性的类型转换，因此无论是运行:
x1 = x1 + 5;
还是:
x1 = 5 + x1;
都能够编译通过。
解决了基本的功能问题，让我们继续考虑一下效率。无论是在x1 = x1 + 5，还是在x1 = 5 + x1，都至少会掉用额外的constructor和destructor把5转换成Test Object,这种浪费是很没有必要的。其次允许compiler进行implicit type conversion并不是一个良好的习惯。解决这些问题的方法，就是提供专用的 operator + 来进行integer和Test object之间的加法操作，具体代码如下：
========== 支持 x1 + 5 ==========
Test operator + ( const Test & Para1, int Para2)
{
return Test(Para2) += Para1;
}
========== 支持 5 + x1 ==========
Test operator + ( int Para1, const Test & Para2 )
{
return Test(Para1) += Para2;
}
同时还要在class Test中加如下面2行(对于此例子并不需要，不过正常情况是需要的)：
friend Test operator + ( int Para1, const Test & Para1 );
friend Test operator + ( const Test & Para1, int Para2 );
并且在constructor前面加上 explicit。当然，你也可以用Template进行定义，如下：
========== 支持 x1 + 5 ==========
template <class T>
T operator + ( const T & Para1, int Para2)
{
return T(Para2) += Para1;
}
实际上对于 template的定义，我个人并不推荐. 首先是因为namespace的问题，到底是global namespace呢？还是一个local namespace？如果是global namespace,那不一定所有的global class 都需要 operator +，这样就提供了多余的class操作。local namespace倒是可以用，前提是所有的class都定义了 +=. 也许对于大多数class来讲，并不需要operator + 的操作。所以我觉得对于 operator 的定义，尽量少用 template （个人观点）.
==================分割线==================
下面说说关于类型转换的operator. 对于一个Abstract Data Type来说，类型转换是经常用到的，比如我们前面提到的从 integer转换成 Test， 可以使用implicit type conversion 和 explicit type conversion. 但是如果我们想从Test 转换成 integer，compiler无法支持自动的类型转换，因此需要我们提供相应的operator:
class Test {
...
// Type converstion from Test to int
operator int() { return internalData; };
}
那么我们就可以执行：
int i = Test(10);
实际上，operator int()又是一种implicit type conversion,这并是收程序员的控制。良好的程序设计，是programmer能够精确的控制每一个细微的操作。因此并不推荐使用 operator int()，好的方法是按照 < effective c++ > 中给出的那样，提供一个asInt() method，来做explicti type conversion:
============ explicti ============
class Test {
...
// Type converstion from Test to int
int asInt() { return internalData; };
}
================== Test++ & ++Test ==================
相信大家都知道 Prefix ++ 和 Postfix ++的区别是什么，下面是代码：
// Prefix
Test& operator++()
{
++internalData;
return (*this);
}
// Postfix
Test operator++(int)
{
++*this;
return --Test(*this); // 为了使用返回值优化，需要定义 --Test
}
我们只是简单的看下效率问题，在 Prefix中也就是 ++ 返回的是reference,没有temporary object,在 Postfix中返回的是个object,使用了Temporary。相信大家都知道了，能不使用 Test++的地方就不要使用，尽量使用 ++Test。
比如：
for( iterator i = XXX; XXX; ++i) // 不要使用 i++
对于postfix, compiler并不能保证肯定会优化成 prefix，所以写代码的时候尽量注意。
================== 其他关于Operator ==================
有些operator，并不推荐进行overload,因为会出现无法预料的情况。这些operator 包括：
&&, || , & , | , ","
举个简单的例子，如果你overload了","，那么有一个for循环如下：
for( Test x1 = x2,i = 0; ; ) {....}
到底是x1 = x2 和 i = 0呢？还是 x1 = x2.operator , (i) = 0 呢？如果overload了 & ，对于逻辑判断，x1 && x2，到底是 x1 && x2呢？还是 x1.operator & (&x2)呢？因此这些overload都会产生很多让人费解的问题。
其次，很多operator overload需要很小心的对待，这些operator 如下：
new new[] delete delete[] -> [] ()
请仔细阅读 C++ 标准，了解详细内容后，再对这些operator进行overload，不然很容易造成程序的不稳定。
