|
|
======================================================
大家请把我的文章当参考，详细内容 还请参照 权威书籍
<c++ programming language>如果文中有错误和遗漏，
请指出，Aear会尽力更正, 谢谢！
======================================================
废话不多说，这次讲的是 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: perator += ( 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 下次见。
|
|
发表于 2006-11-13 06:33:00
