创建型设计模式

 

创建型模式抽象了实例化的过程。它们帮助一个系统独立于如何被创建、组合和表示它的那些对象。一个类创建型模式使用继承改变被实例化的类，而一个对象创建型模式将实例化委托给另一个对象。

 

ABSTRACT FACTORY （抽象工厂） <Kit>

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

 

  适用性

# 一个系统要独立于它的产品的创建、组合和表示时；

# 一个系统要由多个产品系列中的一个来配置时；

# 当要强调一系列相关的产品对象的设计以便进行联合使用时；

# 当提供一个产品类库，而只想显示它们的接口而不是实现时

 

实例

#ifndef ABSTRACTFACTORY_H

#define ABSTRACTFACTORY_H

// 抽象基类 AbstractProductA, 代表产品 A 的抽象

class AbstractProductA

{

public:

AbstractProductA() {}

virtual ~AbstractProductA(){};

};

// 派生类 ConcreateProductA1, 继承自 AbstractProductA, 代表产品 A 的第一种实现

class ConcreateProductA1 : public AbstractProductA

{

public:

ConcreateProductA1();

virtual ~ConcreateProductA1();

};

// 派生类 ConcreateProductA2, 继承自 AbstractProductA, 代表产品 A 的第二种实现

class ConcreateProductA2 : public AbstractProductA

{

public:

ConcreateProductA2();

virtual ~ConcreateProductA2();

};

// 抽象基类 AbstractProductB, 代表产品 B 的抽象

class AbstractProductB

{

public:

AbstractProductB() {}

virtual ~AbstractProductB(){};

};

// 派生类 ConcreateProductB1, 继承自 AbstractProductB, 代表产品 B 的第一种实现

class ConcreateProductB1 : public AbstractProductB

{

public:

ConcreateProductB1();

virtual ~ConcreateProductB1();

};

// 派生类 ConcreateProductB2, 继承自 AbstractProductB, 代表产品 B 的第二种实现

class ConcreateProductB2 : public AbstractProductB

{

public:

ConcreateProductB2();

virtual ~ConcreateProductB2();

};

// 抽象基类 AbstractFactory, 工厂的抽象类 , 生产产品 A 和产品 B

class AbstractFactory

{

public:

AbstractFactory(){}

virtual ~AbstractFactory(){}

virtual AbstractProductA* CreateProductA() = 0;

virtual AbstractProductB* CreateProductB() = 0;

};

// 派生类 ConcreateFactory1, 继承自 AbstractFactory

// 生产产品 A 和产品 B 的第一种实现

class ConcreateFactory1: public AbstractFactory

{

public:

ConcreateFactory1();

virtual ~ConcreateFactory1();

virtual AbstractProductA* CreateProductA();

virtual AbstractProductB* CreateProductB();

};

// 派生类 ConcreateFactory2, 继承自 AbstractFactory

// 生产产品 A 和产品 B 的第二种实现

class ConcreateFactory2: public AbstractFactory

{

public:

ConcreateFactory2();

virtual ~ConcreateFactory2();

virtual AbstractProductA* CreateProductA();

virtual AbstractProductB* CreateProductB();

};

#endif

 

#include <iostream>

#include "AbstractFactory.h"

ConcreateProductA1::ConcreateProductA1()

{

std::cout << "construction of ConcreateProductA1/n";

}

ConcreateProductA1::~ConcreateProductA1()

{

std::cout << "destruction of ConcreateProductA1/n";

}

ConcreateProductA2::ConcreateProductA2()

{

std::cout << "construction of ConcreateProductA2/n";

}

ConcreateProductA2::~ConcreateProductA2()

{

std::cout << "destruction of ConcreateProductA2/n";

}

ConcreateProductB1::ConcreateProductB1()

{

std::cout << "construction of ConcreateProductB1/n";

}

ConcreateProductB1::~ConcreateProductB1()

{

std::cout << "destruction of ConcreateProductB1/n";

}

ConcreateProductB2::ConcreateProductB2()

{

std::cout << "construction of ConcreateProductB2/n";

}

ConcreateProductB2::~ConcreateProductB2()

{

std::cout << "destruction of ConcreateProductB2/n";

}

ConcreateFactory1::ConcreateFactory1()

{

std::cout << "construction of ConcreateFactory1/n";

}

ConcreateFactory1::~ConcreateFactory1()

{

std::cout << "destruction of ConcreateFactory1/n";

}

AbstractProductA* ConcreateFactory1::CreateProductA()

{

return new ConcreateProductA1();

}

AbstractProductB* ConcreateFactory1::CreateProductB()

{

return new ConcreateProductB1();

}

ConcreateFactory2::ConcreateFactory2()

{

std::cout << "construction of ConcreateFactory2/n";

}

ConcreateFactory2::~ConcreateFactory2()

{

std::cout << "destruction of ConcreateFactory2/n";

}

AbstractProductA* ConcreateFactory2::CreateProductA()

{

return new ConcreateProductA2();

}

AbstractProductB* ConcreateFactory2::CreateProductB()

{

return new ConcreateProductB2();

}

 

#include "AbstractFactory.h"

#include <stdlib.h>

int main()

{

// 生产产品 A 的第一种实现

ConcreateFactory1 *pFactory1 = new ConcreateFactory1;

AbstractProductA *pProductA = pFactory1->CreateProductA();

// 生产产品 B 的第二种实现

ConcreateFactory2 *pFactory2 = new ConcreateFactory2;

AbstractProductB *pProductB = pFactory2->CreateProductB();

delete pFactory1;

delete pProductA;

delete pFactory2;

delete pProductB;

system("pause");

return 0;

}

 

 

BUILDER( 生成器 )

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

 

  适用性

# 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时；

# 当构造过程必须被构造的对象有不同表示时

 

实例

#ifndef BUILDER_H

#define BUILDER_H

// 虚拟基类 , 是所有 Builder 的基类 , 提供不同部分的构建接口函数

class Builder

{

public :

Builder() {} ;

virtual ~ Builder() {}

// 纯虚函数 , 提供构建不同部分的构建接口函数

virtual void BuilderPartA() = 0 ;

virtual void BuilderPartB() = 0 ;

} ;

// 使用 Builder 构建产品 , 构建产品的过程都一致 , 但是不同的 builder 有不同的实现

// 这个不同的实现通过不同的 Builder 派生类来实现 , 存有一个 Builder 的指针 , 通过这个来

实现多态调用

class Director

{

public :

Director(Builder * pBuilder);

~ Director();

void Construct();

private :

Builder * m_pBuilder;

} ;

// Builder 的派生类 , 实现 BuilderPartA 和 BuilderPartB 接口函数

class ConcreateBuilder1 : public Builder

{

public :

ConcreateBuilder1() {}

virtual ~ ConcreateBuilder1() {}

virtual void BuilderPartA();

virtual void BuilderPartB();

} ;

// Builder 的派生类 , 实现 BuilderPartA 和 BuilderPartB 接口函数

class ConcreateBuilder2 : public Builder

{

public :

ConcreateBuilder2() {}

virtual ~ ConcreateBuilder2() {}

virtual void BuilderPartA();

virtual void BuilderPartB();

} ;

#endif

 

#include " Builder.h "

#include < iostream >

void ConcreateBuilder1::BuilderPartA()

{

std::cout << " BuilderPartA by ConcreateBuilder1/n " ;

}

void ConcreateBuilder1::BuilderPartB()

{

std::cout << " BuilderPartB by ConcreateBuilder1/n " ;

}

void ConcreateBuilder2::BuilderPartA()

{

std::cout << " BuilderPartA by ConcreateBuilder2/n " ;

}

void ConcreateBuilder2::BuilderPartB()

{

std::cout << " BuilderPartB by ConcreateBuilder2/n " ;

}

Director::Director(Builder * pBuilder): m_pBuilder(pBuilder)

{

}

Director:: ~ Director()

{

delete m_pBuilder;

m_pBuilder = NULL;

}

// Construct 函数表示一个对象的整个构建过程 , 不同的部分之间的装配方式都是一致的 ,

// 首先构建 PartA 其次是 PartB, 只是根据不同的构建者会有不同的表示

void Director::Construct()

{

m_pBuilder -> BuilderPartA();

m_pBuilder -> BuilderPartB();

}

 

#include " Builder.h "

#include < stdlib.h >

int main()

{

Builder * pBuilder1 = new ConcreateBuilder1;

Director * pDirector1 = new Director(pBuilder1);

pDirector1 -> Construct();

Builder * pBuilder2 = new ConcreateBuilder2;

Director * pDirector2 = new Director(pBuilder2);

pDirector2 -> Construct();

delete pDirector1;

delete pDirector2;

system( " pause " );

return 0 ;

}

 

 

FACTORY METHOD( 工厂方法 )< 虚构造器 Virtual Constructor>

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

 

  适用性

# 当一个类不知道它所必须创建的对象的类的时候

# 当一个类希望由它的子类来指定它所创建的对象的时候。

# 当类将创建对象的职责委托给多个帮助子类中的某一个，并且希望将哪一个帮助子类是代理者这一信息局部化时

 

实例

#ifndef FACTORY_H

#define FACTORY_H

class Product

{

public:

Product(){}

virtual ~Product(){}

};

class ConcreateProduct : public Product

{

public:

ConcreateProduct();

virtual ~ConcreateProduct();

};

class Creator

{

public:

Creator(){}

virtual ~Creator(){}

void AnOperation();

protected:

virtual Product* FactoryMethod() = 0;

};

class ConcreateCreator: public Creator

{

public:

ConcreateCreator();

virtual ~ConcreateCreator();

protected:

virtual Product* FactoryMethod();

};

#endif

 

#include "Factory.h"

#include <iostream>

using namespace std;

ConcreateProduct::ConcreateProduct()

{

std::cout << "construction of ConcreateProduct/n";

}

ConcreateProduct::~ConcreateProduct()

{

std::cout << "destruction of ConcreateProduct/n";

}

void Creator::AnOperation()

{

Product* p = FactoryMethod();

std::cout << "an operation of product/n";

}

ConcreateCreator::ConcreateCreator()

{

std::cout << "construction of ConcreateCreator/n";

}

ConcreateCreator::~ConcreateCreator()

{

std::cout << "destruction of ConcreateCreator/n";

}

Product* ConcreateCreator::FactoryMethod()

{

return new ConcreateProduct();

}

 

#include "Factory.h"

#include <stdlib.h>

int main(int argc,char* argv[])

{

Creator *p = new ConcreateCreator();

p->AnOperation();

delete p;

system("pause");

return 0;

}

 

 

PROTOTYPE( 原型 )

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

 

适用性

# 当要实例化的类是在运行时刻指定时，例如通过动态装载；

# 为了避免创建一个与产品类层次平行的工厂层次时；

# 当一个类的实例只能有几个不同状态组合中的一种时，建立相应数目的原型并克隆它们困难比每次用合适的状态手工实例化该类更方便一些。

 

实例

#ifndef PROTOTYPE_H

#define PROTOTYPE_H

// 虚拟基类 , 所有原型的基类 , 提供 Clone 接口函数

class Prototype

{

public:

Prototype(){}

virtual ~Prototype(){}

virtual Prototype* Clone() = 0;

};

// 派生自 Prototype, 实现 Clone 方法

class ConcreatePrototype1: public Prototype

{

public:

ConcreatePrototype1();

ConcreatePrototype1(const ConcreatePrototype1&);

virtual ~ConcreatePrototype1();

virtual Prototype* Clone();

};

// 派生自 Prototype, 实现 Clone 方法

class ConcreatePrototype2: public Prototype

{

public:

ConcreatePrototype2();

ConcreatePrototype2(const ConcreatePrototype2&);

virtual ~ConcreatePrototype2();

virtual Prototype* Clone();

};

#endif

 

#include "Prototype.h"

#include <iostream>

ConcreatePrototype1::ConcreatePrototype1()

{

std::cout << "construction of ConcreatePrototype1/n";

}

ConcreatePrototype1::~ConcreatePrototype1()

{

std::cout << "destruction of ConcreatePrototype1/n";

}

ConcreatePrototype1::ConcreatePrototype1(const ConcreatePrototype1&)

{

std::cout << "copy construction of ConcreatePrototype1/n";

}

Prototype* ConcreatePrototype1::Clone()

{

return new ConcreatePrototype1(*this);

}

ConcreatePrototype2::ConcreatePrototype2()

{

std::cout << "construction of ConcreatePrototype2/n";

}

ConcreatePrototype2::~ConcreatePrototype2()

{

std::cout << "destruction of ConcreatePrototype2/n";

}

ConcreatePrototype2::ConcreatePrototype2(const ConcreatePrototype2&)

{

std::cout << "copy construction of ConcreatePrototype2/n";

}

Prototype* ConcreatePrototype2::Clone()

{

return new ConcreatePrototype2(*this);

}

 

#include "Prototype.h"

#include <stdlib.h>

int main()

{

Prototype* pPrototype1 = new ConcreatePrototype1();

Prototype* pPrototype2 = pPrototype1->Clone();

Prototype* pPrototype3 = new ConcreatePrototype2();

Prototype* pPrototype4 = pPrototype3->Clone();

delete pPrototype1;

delete pPrototype2;

delete pPrototype3;

delete pPrototype4;

system("pause");

return 0;

}

 

 

SINGLETON （单件）

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

适用性

# 当类只能有一个实例而切客户可以从一个众所周知的访问点访问时

# 当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需要改写代码就能使用一个扩展的实例时。

 

实例

#ifndef SINGLETON_H

#define SINGLETON_H

class Singleton

{

public:

Singleton(){};

~Singleton(){};

// 静态成员函数 , 提供全局访问的接口

static Singleton* GetInstancePtr();

static Singleton GetInstance();

void Test();

private:

// 静态成员变量 , 提供全局惟一的一个实例

static Singleton* m_pStatic;

};

#endif

 

#include "Singleton.h"

#include <iostream>

// 类的静态成员变量要在类体外进行定义

Singleton* Singleton::m_pStatic = NULL;

Singleton* Singleton::GetInstancePtr()

{

if (NULL == m_pStatic)

{

m_pStatic = new Singleton();

}

return m_pStatic;

}

Singleton Singleton::GetInstance()

{

return *GetInstancePtr();

}

void Singleton::Test()

{

std::cout << "Test!/n";

}

#include "Singleton.h"

#include <stdlib.h>

int main()

{

// 不用初始化类对象就可以访问了

Singleton::GetInstancePtr()->Test();

Singleton::GetInstance().Test();

system("pause");

return 0;

}

 

 

总结

  用一个系统创建的那些对象的类对系统进行参数化有两种方法。一种是生成创建对象的类的子类；这对应于使用 Factory Method 模式。这种方法的主要缺点是：仅为了改变该产品类，就可能需要创建一个新的子类。这样的改变可能是级联的（ Cascade ）。例如，若产品的创建者本身是由一个工厂方法创建的，那么也必须重新定义它的创建者。

  另一种对系统进行参数化的方法更多的依赖于对象复合：定义一个对象负责明确产品对象的类，并将它作为该系统的参数。这是 Abstract Factory,Builder,Prototype 模式的关键特征。所有这三个模式都涉及到创建一个新的负责创建产品对象的“工厂对象”。 Abstract Factor 由这个工厂对象产生多个类的对象。 Builder 由这个工厂对象使用一个相对复杂的协议，逐步创建一个复杂产品。 Prototype 由该工厂对象通过拷贝原型对象来创建产品对象。在这这种情况下，因为原型负责返回产品对象，所以工厂对象和原型是同一个对象。