第一招虚函数

通过派生类来进行功能扩展是基本的面向对象的方式，这种方式大如下：

class base

{

public:

virtual ~base(){}

virtual void fun()

{

cout << "基本功能" << endl;

}

};

class derive:public base

{

public:

void fun()

{

cout << "扩展功能" << endl;

}

};

这种方式下，基类通过声明虚函数，让派生类来覆盖，最后通过多态来实现扩展功能。这种方式的最大的缺点是基类的编写者一般很难确定虚函数的功能究竟要实现到什么程度，如果有一天突然发现一个虚函数的功能要进行扩张（或收缩），那么所有从这个基类派生的类都要进行编译。这种方式的另一个缺憾是。功能的扩展不能在运行时设定。

第二招组合

通过组合方式来为类的功能扩展留下余地的方式，要比通过继承的方式在耦合方面要松的多。就是把上面的虚函数所要委托给一个其它的类。这种方式大体如下：

class action

{

public:

virtual void fun()

{

cout << "基本功能" << endl;

}

};

class exAction:public action

{

public:

virtual void fun()

{

cout << "扩展功能" << endl;

}

};

class app

{

public:

app():paction(NULL){}

virtual ~app(){}

virtual void fun()

{

if(paction)

paction->fun();

}

void setActoin( action* action_)

{

paction = action_;

}

private:

action* paction;

};

在这个例子中，类app把它的功能委托给了类action。这样一来，类app就和它的功能进行了解藕。解藕后的类app现在可以在运行时进行功能设定了。通过组合的方式虽然解藕了也能进行功能的运行时设定了。但却明显地不如第一种方式效率高。

第三招函数指针成员

通过函数指针成员方式，可以提高效率。这种方式大体如下：

class app

{

public:

app():pfun(NULL){}

virtual ~app(){}

typedef void(*FUN)();

void setFun(FUN fun_)

{

pfun = fun_;

}

virtual void fun()

{

if( pfun)

pfun();

}

private:

FUN pfun;

};

第四招成员模板函数

通过为类预留一个成员模板函数，而为类的使用者留下扩展的余地。这种方式简捷、干练。遗憾的是这种方式不能用在动态方面上。这种方式大体如下：

class app

{

public:

app(){}

virtual ~app(){}

template <class T>

void fun( T& t_)

{

cout << "基本功能" << endl;

}

};

template < >

void app::fun(int & t_)

{

cout << "扩展功能" << endl;

}

这种方式还能依偏特化的形式进行，具体请参考我的另一篇blog《让后门能够偏特化》。使用这种方式最奇妙的是声明一个模板构造函数来扩展类的构造功能。

第五招模板基类

上面的几种方式都是针对一个要进行开发的类为这个要开发的类留下扩展余地。那么能不能让要开发的类用来扩展任意的已开发好的类的功能呢？这就是第五招模板基类。这种方式大体如下：

template < class T>

class exApp:public T

{

public:

void fun()

{

cout << "扩展功能" << endl;

}

};

现在我们可以方便的把类exApp的功能添加到任意的其它的类上了。这种扩展方式的功能非常强悍，它甚至引出一个专门的编程方式：“基于策略的编程”。

详见《C++程序设计就思维》。

原文转自：http://blog.csdn.net/guanwl/article/details/2358073

原作者为 guanwl。请尊重原作者版权