C++设计新思维——基于Policy的Class设计

Policy设计思路的来源：

    软件设计，就是选择一种当前最优，而且在未来能得到很好扩展，便于维护的设计方案。通常都有多种可用的设计方案，而设计过程就是抉择的过程。

    在软件设计中，常常会有这样的需求，对一个对象有大量的功能需求。此时常用的设计方案是：设计一个全功能型接口。然而，一个全功能型接口，将过于庞大，以至难以维护。好的设计应该是足够精巧的，而又清晰明了的。

    故对于有大量功能需求的对象而言，全功能型接口不是好的选择。那么从另一个方向出发，则是将对象的功能分解，设计多个类来维护各种类型的接口，并尽量做到每个功能类的高内聚，功能类之间的低耦合。于是自然而然，产生这样的一种解法：多重继承。即对象实际所需功能是通过继承自多个功能类而得的。然而，多重继承的问题在于，“基类并没有足够的型别信息来完成它们的工作”。其实，我觉得这句话有点意思，举个例子：

#include <iostream>
#include <tr1/memory>

using std::cin ;
using std::cout ;
using std::endl ;
using std::tr1::shared_ptr ;

class WidgetNew ;
class WidgetStatic ;

class CreatorNew
{
public :
   CreatorNew( ) { cout << "Create CreatorNew Obj ! " << endl ; }

   ~CreatorNew( ) { cout << "Destroy CreatorNew Obj ! " << endl ; }

   shared_ptr<WidgetNew> CreateObj( );
} ;

class WidgetNew : public CreatorNew
{
public :
   WidgetNew( ) { cout << "Create WidgetNew Obj !" << endl ; }

   ~WidgetNew( ) { cout << "Destroy WidgetNew Obj !" << endl ; }
} ;

shared_ptr<WidgetNew> CreatorNew::CreateObj( )
{
   cout << "Create with new operator !" << endl ;

   return shared_ptr<WidgetNew>( new WidgetNew( ) );
}

class CreatorStatic
{
public :
   CreatorStatic( ) { cout << "Create CreatorStatic Obj ! " << endl ; }

   ~CreatorStatic( ) { cout << "Destroy CreatorStatic Obj ! " << endl ; }

   WidgetStatic& CreateObj( );
} ;

class WidgetStatic : public CreatorStatic
{
public :
   WidgetStatic( ) { cout << "Create WidgetStatic Obj !" << endl ; }

   ~WidgetStatic( ) { cout << "Destroy WidgetStatic Obj !" << endl ; }
} ;

WidgetStatic& CreatorStatic::CreateObj( )
{
   cout << "Create with static obj !" << endl ;

   static WidgetStatic _wid ;

   return _wid ;
}

int main( int argc, char **argv )
{
   cout << "------------- Create WidgetManager Object ! ------------" << endl ;

   WidgetNew a_wid ;

   WidgetStatic b_wid ;

   cout << endl << "-- Create WidgetManager Object With CreateObj Method (New) ! --" << endl ;

   a_wid.CreateObj( ) ;

   cout << endl << "-- Create WidgetManager Object With CreateObj Method (Static) ! --" << endl ;

   b_wid.CreateObj( ) ;

   cout << endl << "------------ Destroy WidgetManager Object ! ------------" << endl ;

   return 0 ;
}

其中对于Widget对象有两种Create功能，分别实现于CreatorNew和CreatorStatic中，然而Creator的目的是要创建具备该功能的子类对象，但是继承自Creator的子类是无限的，所以CreateObj接口的返回类型是可变的。可能有人会觉得，把Creator里的CreateObj接口声明为Virtual然后采用多态，不就解决了，有必要搞得那么复杂（我最初也是这样觉得的），可关键在于，多态要在运行期，才能确定最终的调用函数，而现在考虑的是要在编译期就确定下来，此外，当前的设计考虑的是将功能分解到多个类里面来管理，如果只是在一个超类里声明接口，而将实现放在具体的派生类，显然违背了设计的本意（本意是让各个类尽量精简，清晰明了）。所以我们不能采用多态的方式来解决。

    故，单纯使用多重继承，并非好的选择。但是多重继承又是一个正确的思路，因为要么就将功能集中处理，也就是设计全功能接口，要么就将功能分解，也就是多重继承，显然多重继承是正确的。现在的问题是在于，多重继承时，派生类的类型对于超类是不可知的。所以最好的方法是让编译器能自动根据当前派生类实现出对应的超类。显然，具备这样特性的就是Template。于是乎，上述代码可修改如下：（测试地址：http://codepad.org/YsBxraK1 ）

#include <iostream>
#include <tr1/memory>

using std::cin ;
using std::cout ;
using std::endl ;
using std::tr1::shared_ptr ;

template< class T >
class CreatorNew
{
public :
   CreatorNew( ) { cout << "Create CreatorNew Obj ! " << endl ; }

   ~CreatorNew( ) { cout << "Destroy CreatorNew Obj ! " << endl ; }

   shared_ptr<T> CreateObj( )
   {
      cout << "Create with new operator !" << endl ;
      return shared_ptr<T>( new T( ) );
   }
} ;

template< class T >
class CreatorStatic
{
public :
   CreatorStatic( ) { cout << "Create CreatorStatic Obj ! " << endl ; }

   ~CreatorStatic( ) { cout << "Destroy CreatorStatic Obj ! " << endl ; }

   T& CreateObj( )
   {
      cout << "Create with static obj !" << endl ;

      static T _t ;

      return _t ;
   }
} ;


template< template< class > class CreationPolicy >
class WidgetManager : public CreationPolicy< WidgetManager<CreationPolicy> >
{
public :
   WidgetManager( ) { cout << "Create WidgetManager Obj !" << endl ; }

   ~WidgetManager( ) { cout << "Destroy WidgetManager Obj !" << endl ; }
} ;

int main( int argc, char **argv )
{
   cout << "------------- Create WidgetManager Object ! ------------" << endl ;

   WidgetManager< CreatorNew > a_wid ;

   WidgetManager< CreatorStatic > b_wid ;

   cout << endl << "-- Create WidgetManager Object With CreateObj Method (New) ! --" << endl ;

   a_wid.CreateObj( ) ;

   cout << endl << "-- Create WidgetManager Object With CreateObj Method (Static) ! --" << endl ;

   b_wid.CreateObj( ) ;

   cout << endl << "------------ Destroy WidgetManager Object ! ------------" << endl ;

   return 0 ;
}

运行结果：

------------- Create WidgetManager Object ! ------------
Create CreatorNew Obj ! 
Create WidgetManager Obj !
Create CreatorStatic Obj ! 
Create WidgetManager Obj !

-- Create WidgetManager Object With CreateObj Method (New) ! --
Create with new operator !
Create CreatorNew Obj ! 
Create WidgetManager Obj !
Destroy WidgetManager Obj !
Destroy CreatorNew Obj ! 

-- Create WidgetManager Object With CreateObj Method (Static) ! --
Create with static obj !
Create CreatorStatic Obj ! 
Create WidgetManager Obj !

------------ Destroy WidgetManager Object ! ------------
Destroy WidgetManager Obj !
Destroy CreatorStatic Obj ! 
Destroy WidgetManager Obj !
Destroy CreatorNew Obj ! 
Destroy WidgetManager Obj !
Destroy CreatorStatic Obj !