C++ Exceptional 模板设计模式(Template Design Model)

首先看一下下面一段代码：

class GenericTableAlgorithm
{
public:
    GenericTableAlgorithm(const string& table);
    virtual ~GernericTableAlgorithm();
    // Process() returns true if and only if successful.
    // It does all the work: a) physically reads the
    // table's records, calling Filter() on each to 
    // determine whether it should be included in the
    // rows to be processed; and b) when the list of rows
    // to operate upon is complete, calls ProcessRow()
    // for each such row.
    bool Process();
private:
    // Filter() returns true if and only if the row
    // should be included in the ones to be processed.
    // The default action is to return true (to include
    // every row.
    virtual bool Filter(const Records&);
    // ProcessRow() is called once per record that
    // was included for processing. This is where
    // the concrete class does its specialized work.
    // (Note: This means every row to be processed
    //  will be read twice, but assume that that is
    // necessary and not an efficiency consideration. )
    virtual bool ProcessRow(const PrimaryKey&) = 0;
    struct GenericTableAlgorithmImpl* pimpl_; //MYOB
};

class MyAlgorithm : public GenericTableAlgorithm
{
    // ...override Filter and ProcessRow() to
    // implement a specific operation
};

int main(int argc, char *argv[])
{
    MyAlgorithm a("Customer");
    a.Process();
}

1. 首先上面类的设计用到的就是模板设计模式，模板设计模式具体的定义如下：
   定义一个操作中的算法的骨架，而将步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义算法的某些特定步骤。

2. 上面的类虽然用到了模板设计模式，但并不是最优的解决方案。一种更好的方案是把父类和子类解构，减少子类对父类的依赖。改善后的代码如下：

//-----------------------------------------------
// File gta.h
//-----------------------------------------------
// Responsibility #1: Providing a public interface that
// encapsulates common functionality as a template method
// This has nothing to do with inheritance relationships, // and can be nicely isolated to stand on its own in a 
// better-focused class. The target audience is external // users of GenericTableAlgorithm.

class GTAClient;

class GenericTableAlgorithm
{
public:
    // Constructor now takes a concrete implementation
    // object.
    GenericTableAlgorithm(const string& table,
                          GTAClient& worker);

    // Since we've separated away the inheritance 
    // relationships, the destructor doesn't need to
    // be virtual
    ~GenericTableAlgorithm();
    bool Process(); // unchanged
private:
    struct GenericTableAlgorithmImpl* pimpl_; //MYOB
};

//-------------------------------------------------
// File gtaclient.h
//-------------------------------------------------
//Responsibility #2: Providing an abtract interface
// for extensibility. This is an implementation detail
// of GenericTableAlgorithm that has nothing to do with
// its external clients, and can be nicely separated out
// into a better-focused abstract protocol class. The 
// target audience is writers of concrete "implementation // detail" classes which work with (and extend)
// GenericTableAlgorithm.

class GTAClient
{
public:
    virtual ~GTAClient() = 0;
    virtual bool Filter(const Records&);
    virtual bool ProcessRow(const PromaryKey&) = 0;
}

//--------------------------------------------
// File gtaclient.cpp
//--------------------------------------------
bool GTAClient::Filter(const Record&)
{
    return true;
}

class MyWorker : public GTAClient
{
    // ... override Filter() and ProcessRow() to
    // implement a specific operation ...
};

int main()
{
    GenericTableAlgorithm a("Customer", MyWorker());
    a.Process();
}

以上代码成功地解构了第一种设计方式子类和父类之间的依赖关系，GenericTableAlgorithm和GTAClient之间是一种组合模式，而不是一种继承关系。类与类之间的关系更明确，更清晰。

当然还有一种比以上组合模式更简单的方法，那就是利用模板，如下：

template<typename GTACworker>
bool GenericTableAlgorithm( const string& table)
{
    // ...original contents of Process() go here ...
}

int main()
{
    GenericTableAlgorithm<MyWorker>("Customer");
}

以上方法更加简便和通用。