C++基本功和 Design Pattern系列 Operator 下

继续上一章的内容，下面是经过调整后的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，不然很容易造成程序的不稳定。

C++基本功和 Design Pattern系列 Operator 下相关推荐

几种常用的设计模式（Design Pattern)
文章目录设计模式(Design Pattern) 一.设计模式的分类 1. 基础型模式 (Fundamental Pattern) 2. 创建型模式 (Creational Pattern) 3. ...
说说设计模式~大话目录(Design Pattern)
回到占占推荐博客索引设计模式(Design pattern)与其它知识不同,它没有华丽的外表,没有吸引人的工具去实现,它是一种心法,一种内功,如果你希望在软件开发领域有一种新的突破,一个质的飞越,那 ...
Design Pattern - Command （C#）
分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow 也欢迎大家转载本篇文章.分享知识,造福人民,实现我们中华民族伟大复兴! Defi ...
Design Pattern: Observer Pattern
1. Brief 一直对Observer Pattern和Pub/Sub Pattern有所混淆,下面打算通过这两篇Blog来梳理这两种模式.若有纰漏请大家指正. 2. Use Case 首先我们来面 ...
Design Pattern Quick Overview
Do we really need this design pattern? Just ignore, all the big guys requires it. For you, just unde ...
初读设计模式-----《design pattern explained》读后感
从网上淘来了一本<design pattern explained>,用了半个月的时间细细的读完了这本书. 本打算单单的从技术角度进行总结的,但是却全然没有头绪.说说自己的粗浅的感悟吧.. ...
设计模式（Design Pattern）
简介设计模式(Design Pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用.设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案.这些解决方案是众多软件开发人 ...
python singleton design pattern super() 多继承
python singleton design pattern decorate baseclass metaclass import module super() 一.A decorator de ...
设计模式（Design pattern—
设计模式(Design Pattern)系列视频教程(附PDF文档) 设计模式(Design pattern-使用设计模式是为了可重用代码.让代码更容易被他人理解.保证代码可靠性. 毫无疑问,设计模式 ...

C++基本功和 Design Pattern系列 Operator 下

C++基本功和 Design Pattern系列 Operator 下相关推荐

最新文章

热门文章