0. Introduction

接触设计模式有两年时间了，但一直没有系统整理过，为了不至于让自己的思维被繁琐的工作一点点禁锢，还是决定总结一下，为了能够真正做到有所收获，整个系列会按照GoF的Design Patterns: Elements of Reusable Object-Oriented Software的行文思路，但不会照本宣科就是了，Wikipedia上关于23种设计模式的介绍非常全面，CSDN上也可以下载中/英文电子档，因此很多套话、类图一概省去。

最早接触设计模式的时候，难免被各种模式的联系和区别所困扰，从教科书的分析可以得到模式之间形式上的不同。但这样对于领会设计模式意义不大，因为我们掌握模式的目的是为了融会贯通，灵活运用，以对开发有所帮助。

稍微成规模的OO程序，会有大量对象，其中很多实体对象之间存在着父子、兄弟关系，对象的创建提升为一种模式。其好处在于设计模式本身所宣称的reusable，这就像堆积木盖房子一样，堆的好的情况下，换一换门窗便是另一番风景。

关于实现，我不会为了厘清模式间的区别而刻意使用相似代码实现，相反，我会根据模式本身的适用情况举例，而且大量代码基于SourceMaking。

_______________________________

1. Creational Design Patterns(DP)

创建型DP抽象了类和对象的创建过程，GoF给出了5种创建型DP：Abstract Factory、Builder、Factory Method、Builder、Prototype、Singleton。

2. Abstract Factory

意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

1) 只提供了一个创建接口，其返回值为具体产品：如AbstractProduct *Client::CreateProduct(AbstractFactory &factory);

2) 接口的参数是一个工厂对象（AbstractFactory &factory）的引用，参数类型（AbstractFactory）为抽象基类，调用时根据需要传入具体工厂对象即可；

3) 接口内部实现了一系列相关或相互依赖对象（抽象产品）的创建：当传入具体工厂时，接口实现的就是一系列具体产品的创建；

4) 创建的产品立即返回（CreateProduct）。

参与者：

• AbstractFactory
— 声明一个创建抽象产品对象的操作接口。

• ConcreteFactory
— 实现创建具体产品对象的操作。

• AbstractProduct
— 为一类产品对象声明一个接口。

• ConcreteProduct
— 定义一个将被相应的具体工厂创建的产品对象。
— 实现AbstractProduct接口。

• Client
— 仅使用由AbstractFactory和AbstractProduct类声明的接口。

代码：

class AbstractFactory
{
public:
    virtual AbstractProduct *MakePartA() = 0;
    virtual AbstractProduct *MakePartB() = 0;
    virtual AbstractProduct *MakePartC() = 0;
    virtual AbstractProduct *AddPart(const AbstractProduct *pPart) = 0;
};

AbstractProduct *Client::CreateProduct(AbstractFactory &factory)
{
    AbstractProduct *pProduct = factory.CreateProduct();
    AbstractProduct *pPartA = factory.MakePartA();
    AbstractProduct *pPartB = factory.MakePartB();
    AbstractProduct *pPartC = factory.MakePartC();
    factory.AddPart(pPartA);
    factory.AddPart(pPartB);
    factory.AddPart(pPartC);
    return pProduct;
}

int main(void)
{
    Client client;           
    ConcreteFactory factory;
    client.CreateProduct(factory);
    return 0;
}

3. Builder

意图：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

1) director提供抽象产品创建接口：如void Director::Construct();

2) 不同产品使用同一创建过程，由director指定特定builder以生产不同产品；

3) 接口内部实现了一个复杂对象（抽象产品）的创建：当传入具体工厂时，接口实现的是一个复杂的具体产品的创建；

4) 创建的产品并不立即返回，创建完毕后返回，或使用接口（GetProduct）提取结果。

参与者：

• Builder
— 为创建一个Product对象的各个部件指定抽象接口。

• ConcreteBuilder
— 实现Builder的接口以构造和装配该产品的各个部件。
— 定义并明确它所创建的表示。
— 提供一个检索产品的接口。

• Director
— 构造一个使用Builder接口的对象。

• Product
— 表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程。
— 包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

代码：

class Builder
{
public:
    virtual void MakePartA() = 0;
    virtual void MakePartB() = 0;
    virtual void MakePartC() = 0;

    Product *GetProduct()    { return _product; }

protected:
    Product *_product;
};

class Director
{
public:
    void setBuilder(Builder *b)    { _builder = b; }
    void Construct();

private:
    Builder *_builder;
};

void Director::Construct()
{
    _builder.MakePartA();
    _builder.MakePartB();
    _builder.MakePartC();
}

int main(void) {
    ConcreteBuilderA concreteBuilderA;
    ConcreteBuilderB concreteBuilderB;
    Director director;
    Product *pProduct;

    director.SetBuilder(&concreteBuilderA);
    director.Construct();
    pProduct = concreteBuilderA.GetProduct();
    pProduct->Show();

    director.SetBuilder(&concreteBuilderB);
    director.Construct();
    pProduct = concreteBuilderB.GetProduct();
    pProduct->Show();

    return 0;
}

4. Factory Method

意图：定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

1) 看得出该模式其实就是C++的多态特性，借继承实现。因此，其别名为虚构造器（ Virtual Constructor）；

2) 作为模式与C++多态特性不同的是，Creator可以定义工厂方法的缺省实现，完成缺省操作，MFC大量使用了这一思想。

参与者：

• Product
— 定义工厂方法所创建的对象的接口。

• ConcreteProduct
— 实现Product接口。

• Creator
— 声明工厂方法，该方法返回一个Product类型的对象。Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。
— 可以调用工厂方法以创建一个Product对象。

• ConcreteCreator
— 重定义工厂方法以返回一个ConcreteProduct实例。

代码：

ConcreteProduct *ConcreteCreator::FactoryMethod()
{
    ConcreteProduct *pProduct = new ConcreteProduct;
    return pProduct;
}

Product *Creator::FactoryMethod()
{
    Product *pProduct = new Product;
    return pProduct;
}

int main(void) {
    Creator creator;
    ConcreteProduct *pProduct;

    pProduct = creator.FactoryMethod();
    pProduct->Show();

    return 0;
}

5. Prototype

意图：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

1) 创建不再通过工厂新类继承（inheritance），而是通过委托（delegation）；

2) 根通拷贝原型实例创建新对象。

参与者：

• ProtoType
— 声明一个克隆自身的接口。

• ConcreteProtoType
— 实现一个克隆自身的操作。

• Client
— 让一个原型克隆自身从而创建一个新的对象。

代码：

class ProtoType
{
public:
    virtual void Draw();
    virtual ProtoType *Clone() = 0;
    virtual void Initialize();
};

class ProtoTypeA: public ProtoType
{
public:
    virtual ProtoType *Clone()
    {
        return new ProtoTypeA;
    }
};

class ProtoTypeB: public ProtoType
{
public:
    virtual ProtoType *Clone()
    {
        return new ProtoTypeB;
    }
};

class Client
{
public:
    static ProtoType *Clone( int choice );

private:
    static ProtoType *s_prototypes[3];
};

ProtoType* Client::s_prototypes[] = { 0, new ProtoTypeA, new ProtoTypeB };

ProtoType *Client::Clone(int choice)
{
    return s_prototypes[choice]->Clone();
}

6. Singleton

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

1) 用静态成员函数保证上述意图。

参与者：

• Singleton
— 定义一个Instance操作，允许客户访问它的唯一实例。Instance是一个类操作（即C++中的一个静态成员函数）。
— 可能负责创建它自己的唯一实例。

代码：

class Singleton
{
public:
    static Singleton *GetInstance()
    {
        if (!s_instance)
            s_instance = new Singleton;
        return s_instance;
    }

    void Run()    {}

private:
    static Singleton *s_instance;
    Singleton()    {}                // Singleton cannot be created outside.
};

Singleton *GetSingleton(void)
{
    return Singleton::GetInstance();
}

int main(void)
{
    GetSingleton()->Run();

    return 0;
}

______________________________________________

代码写的都比较简单，基本可以将各种模式之间的不同体现出来了。