23种设计模式之五种创建型模式

知也无涯12345

已于 2022-04-28 10:50:29 修改

阅读量343

点赞数

分类专栏：设计模式文章标签： c++ 设计模式

于 2020-03-07 13:48:48 首次发布

本文链接：https://blog.csdn.net/m0_37604894/article/details/104713479

版权

设计模式专栏收录该内容

10 篇文章 0 订阅

订阅专栏

创建型模式（Creational Patterns）用于构建对象，以便它们可以从实现系统中分离出来。
结构型模式（Structural Patterns）用于在许多不同的对象之间形成大型对象结构。
行为型模式（Behavioral Patterns）用于管理对象之间的算法、关系和职责。

第一部分：创建型模式

1. Factory模式

a. 问题

简单工厂模式：
在这里插入图片描述
这个实现比较简单，Factory类直接就创建产品，需要指名产品类型，type为A就创建A产品，为B就创建B产品，适用于工厂类负责创建的对象比较少，createProduct中逻辑简单。这种简单的做法存在一些问题：

由于工厂类集中了所有产品的创建逻辑（违反了高内聚责任分配原则），职责过重，一旦无法正常工作，整个系统都将受到影响。
一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。

Factory模型可以解决这些问题：
1）在父类中并不知道具体要实例化哪一个具体的子类：factory，product两个抽象基类，宝马工厂创建宝马产品，奥迪工厂生产奥迪汽车，我们在factory基类中不知道到底要创建哪个产品，因此，需要将具体化类的工作延迟到子类中。
2）定义创建对象的接口，封装了对象的创建：一个工厂可能有很多产品，将具体化产品的操作进行了封装，具体实现就是，factory中有一个create函数，里面创建不同的产品。
3) 适用于一个类不知道它所创建对象的具体类的时候，或者希望它的子类来指定要创建的对象，或者类将创建对象的职责托付给子类。

具体而言Factory模式适用于：

对于某个产品，调用者清楚地知道应该使用哪个具体工厂服务，实例化该具体工厂，生产出具体的产品来。
只是需要一种产品，而不想知道也不需要知道究竟是哪个工厂生产的，即最终选用哪个具体工厂的决定权在生产者一方，它们根据当前系统的情况来实例化一个具体的工厂返回给使用者，而这个决策过程对于使用者来说是透明的。

b. 结构示意图

在这里插入图片描述

c. 代码实例

//main.cpp
#include "Factory.h"
#include "Product.h"
#include <iostream> 
using namespace std;

int main(int argc,char* argv[]) {
 	Factory* facA = new ConcreteFactoryA();
	Product* p = facA->CreateProduct("A");         //产品A

	Factory* facB = new ConcreteFactoryB();
	Product* p = facB->CreateProduct("B");       //产品B
	return 0; 
}

**//Factory.h**
#ifndef _FACTORY_H_
 #define _FACTORY_H_
class Product;                                     //类对象，需要声明
class Factory { 
public: 
	virtual ~Factory() = 0;
	virtual Product* CreateProduct() = 0;          //封装了对象的创建
protected: 
	Factory();                                     //接口类，保护构造函数
private:

};

class ConcreteFactoryA:public Factory              //工厂的子类，这里比如工厂A，生产产品：汽车、轮子、等
{ 
public:
	~ConcreteFactoryA();
	ConcreteFactoryA();
	Product* CreateProduct(string ProductID);
protected:
private:
};
#endif //~_FACTORY_H_

**//Factory.cpp**
#include "Factory.h"
#include "Product.h"
#include <iostream> 
using namespace std;
Factory::Factory() {
}
Factory::~Factory() {
}

ConcreteFactoryA::ConcreteFactoryA() { 
	cout<<"BMW car Factory....."<<endl; 
}
ConcreteFactoryA::~ConcreteFactoryA() {

}
Product* ConcreteFactoryA::CreateProduct(string ProductID) { 
	if(ProductID == "A")
		return new ProductA();           //A工厂生产产品A             Problem1： 参数化工厂方法，每个工厂生产的产品不确定
	if(ProductID == "B")
		return new ProductB();          //A工厂生产产品B
	return 0；
}

**// product.h**    // 产品基类接口
#ifndef PRODUCT_H
#define PRODUCT_H
#include <string>
using namespace std;
class Product
{
public:
    virtual ~Product（） = 0;  
 protected:
 	Product();
};
#endif // PRODUCT_H

**// concrete_product.h**
#ifndef CONCRETE_PRODUCT_H
#define CONCRETE_PRODUCT_H
#include "product.h"
//产品A
class ProductA: public Product
{
public:
    ProductA（）{
		cout << "create productA" << endl；
	}
};
// 产品B
class ProductB: public Product
{
public:
    ProductB（）{
		cout << "create productB" << endl；
	}
};
#endif // CONCRETE_PRODUCT_H

上述方法还存在一个问题，如果没有ProductID，要创建一个产品，就需要创建一个工厂子类，可以通过模板解决。

template<typename TheProduct>
class StandardFactory:public factory{
public:
	virtual Product* CreateProduct();
}
template<typename TheProduct>
Product* StandardFactory<TheProduct>::CreateProduct(){
	return new TheProduct;
}

主函数调用：
Factory* facA = newStandardFactory<ProductA>();
Product* p = facA->CreateProduct();         //产品A

一个工厂创建多个产品，factory中加入相应的创建函数

**//Factory.h**
#ifndef _FACTORY_H_
 #define _FACTORY_H_
class Product;                                     //类对象，需要声明
class Factory { 
public: 
	virtual ~Factory() = 0;
	virtual Product* CreateProduct() = 0;          //封装了对象的创建
	virtual allProducts* MakeProducts()const{      //allProducts是一个管理所有产品的类或者结构体
		return new allProducts();
	}
	virtual ProductA* MakeProductA()const{
		return new ProductA();
	}
	virtual ProductB* MakeProductB()const{
		return new ProductB();
	}
	.............基类中virtual定义所有的产品
protected: 
	Factory();                                     //接口类，保护构造函数
private:

};

class ConcreteFactoryA:public Factory              //工厂的子类，这里比如工厂A，生产产品：汽车、轮子、等
{ 
public:
	~ConcreteFactoryA();
	ConcreteFactoryA();
	allProducts* CreateProduct(){
		allProducts* Products = MakeProducts():
		ProductA* A = MakeProductA();
		ProductA* B = MakeProductB();
		Products.add(A);
		Products.add(B);
		return Products;
	}
	virtual ProductA* MakeProductA()const{
		return new ProductA();                  //这么写是方便扩展，也可以是A的子类之类的
	}
	virtual ProductB* MakeProductB()const{
		return new ProductB();
	}
protected:
private:
};
#endif //~_FACTORY_H_

c. 代码实例2：

#include "concrete_factory.h"
#include "product.h"
#include <iostream>

#ifndef SAFE_DELETE
#define SAFE_DELETE(p) { if(p){delete(p); (p)=NULL;} }
#endif

int main()
{
    // 奔驰
    AFactory *pFactory = new BenzFactory();
    ICar *pCar = pFactory->CreateCar();
    cout << "Benz factory: " << pCar->Name() << endl;

    SAFE_DELETE(pCar);
    SAFE_DELETE(pFactory);

    // 宝马
    pFactory = new BmwFactory();
    pCar = pFactory->CreateCar();
    cout << "Bmw factory: " << pCar->Name() << endl;

    SAFE_DELETE(pCar);
    SAFE_DELETE(pFactory);

    // 奥迪
    pFactory = new AudiFactory();
    pCar = pFactory->CreateCar();
    cout << "Audi factory: " << pCar->Name() << endl;

    SAFE_DELETE(pCar);
    SAFE_DELETE(pFactory);

    getchar();

    return 0;
}

#ifndef FACTORY_H
#define FACTORY_H

#include "product.h"

// 工厂接口
class AFactory
{
public:
    virtual ICar* CreateCar() = 0;  // 生产汽车
};

#endif // FACTORY_H


#ifndef CONCRETE_FACTORY_H
#define CONCRETE_FACTORY_H

#include "factory.h"
#include "concrete_product.h"

// 奔驰工厂
class BenzFactory : public AFactory
{
public:
    ICar* CreateCar() {
        return new BenzCar();
    }
};

// 宝马工厂
class BmwFactory : public AFactory
{
public:
    ICar* CreateCar() {
        return new BmwCar();
    }
};

// 奥迪工厂
class AudiFactory : public AFactory
{
public:
    ICar* CreateCar() {
        return new AudiCar();
    }
};

#endif // CONCRETE_FACTORY_H

产品：

#ifndef PRODUCT_H
#define PRODUCT_H

#include <string>

using namespace std;

// 汽车接口
class ICar
{
public:
    virtual string Name() = 0;  // 汽车名称
};

#endif // PRODUCT_H


#ifndef CONCRETE_PRODUCT_H
#define CONCRETE_PRODUCT_H

#include "product.h"

// 奔驰汽车
class BenzCar : public ICar
{
public:
    string Name() {
        return "Benz Car";
    }
};

// 宝马汽车
class BmwCar : public ICar
{
public:
    string Name() {
        return "Bmw Car";
    }
};

// 奥迪汽车
class AudiCar : public ICar
{
public:
    string Name() {
        return "Audi Car";
    }
};

#endif // CONCRETE_PRODUCT_H

d. 局限性

a) Factory模式对于对象的创建给予开发人员提供了很好的实现策略，但是Factory模式仅仅局限于一类类（就是说Product是一类，有一个共同的基类，或者后面allproducts也是一类），如果我们要为不同类的类提供一个对象创建的接口，那就要用AbstractFactory了。
b) 每增加一个产品，相应的也要增加一个子工厂，加大了额外的开发量。（可以通过模板解决，或者参数化工厂解决）

2. AbstactFactory模式

a. 问题

抽象工厂模式是更一般的工厂模式，前面的Factory模式产品只能继承一个基类，也就是只有一个类型的产品，Abstract Factory可以创建一组相关或相互依赖的对象。

b. 结构示意图

在这里插入图片描述

c.代码实现

服务端：工厂

基类
//AbstractFactory.h
#ifndef _ABSTRACTFACTORY_H_ 
#define _ABSTRACTFACTORY_H_
class AbstractProductA; 
class AbstractProductB;
class AbstractFactory { 
public: 
	virtual ~AbstractFactory();
	virtual AbstractProductA* CreateProductA() = 0;
	virtual AbstractProductB* CreateProductB() = 0;
	enum FACTORY_TYPE {
        FACTORY1,  // 工厂1
        FACTORY2,  // 工厂2
    };
    static AbstractFactory* CreateFactory(FACTORY_TYPE factory);  // 创建工厂，根据枚举类型自己选择创建工厂类型
protected: 
	AbstractFactory();
private:
};
AbstractFactory* AbstractFactory::CreateFactory(FACTORY_TYPE factory)
{
    AbstractFactory* pFactory = NULL;
    switch (factory) {
    case FACTORY_TYPE::FACTORY1:  // 工厂1
        pFactory = new Factory1();
        break;
    case FACTORY_TYPE::FACTORY2:  // 工厂2
        pFactory = new Factory2();
        break;
    default:
        break;
    }
    return pFactory;
}

class ConcreteFactory1:public AbstractFactory { 
public:
	ConcreteFactory1();
	~ConcreteFactory1();
	AbstractProductA* CreateProductA()
	{ 
		return new ProductA1(); 
	}
	AbstractProductB* CreateProductB()
	{ return new ProductB1(); }
protected:
private:
};
class ConcreteFactory2:public AbstractFactory { 
public: 
	ConcreteFactory2();
	~ConcreteFactory2();
	AbstractProductA* CreateProductA()
	{ return new ProductA2(); }
	AbstractProductB* CreateProductB()
	{ return new ProductB2(); }
protected:
private:
}; #endif //~_ABSTRACTFACTORY_H_

服务端：产品

#include "Product.h"
#include <iostream> 
using namespace std;
AbstractProductA::AbstractProductA() {}
AbstractProductA::~AbstractProductA() {}
AbstractProductB::AbstractProductB() {}
AbstractProductB::~AbstractProductB() {}
ProductA1::ProductA1() { cout<<"ProductA1..."<<endl; }
ProductA1::~ProductA1() {}
ProductA2::ProductA2() { cout<<"ProductA2..."<<endl; }
ProductA2::~ProductA2() {}
ProductB1::ProductB1(){ cout<<"ProductB1..."<<endl; }
ProductB1::~ProductB1() {}
ProductB2::ProductB2() { cout<<"ProductB2..."<<endl; }
ProductB2::~ProductB2() {}

客户端：

#include "AbstractFactory.h"
#include <iostream> 
using namespace std;
int main(int argc,char* argv[]) 
{ 
	//AbstractFactory* cf1 = new ConcreteFactory1();
	AbstractFactory* cf1 = AbstractFactory::CreateFactory(AbstractFactory::FACTORY_TYPE::FACTORY1);
	ProductA* A1=cf1->CreateProductA();      //A1产品
	ProductB* B1=cf1->CreateProductB();      //B1产品
	AbstractFactory* cf2 = new ConcreteFactory2(); 
	ProductA* A2=cf2->CreateProductA();      //A2产品
	ProductB* B2=cf2->CreateProductB();      //B2产品
	return 0; 
}

d.优缺点

优点：

工厂方法只能创建一个类型的产品，抽象工厂可以创建多个类型的产品，相当于对产品进行归类，将几个产品划分为一组，每个工厂负责生产一组产品，客户端使用时只需创建具体工厂实例即可，然后调用这个具化的产品就可以得到产品对象
有利于产品的一致性：当一个系列中的产品对象被设计成一起工作时，一个应用一次只能使用同一系列种的对象，可以通过抽象工厂实现

缺点：

如果产品分组较多，要创建很多具体的工厂，不好管理，而且结构看起来很不精简
难以支持新品种的产品：如果新增一种产品，很多工厂都需要添加这个产品，就要修改抽象工厂和很多concrete工厂，很不方便，所以适用于产品种类变化不大的情况

3. Singleton模式

a. 问题

这个对象（类）只能有一个实例，C++（面向对象和面向过程的结合）的话可以通过设置一个全局变量来实现，如果时纯面向对象的Java，就需要Singleton模式来实现了（不会Java，这句话不太懂，-……-），C++当然也可以这样用啦。

b.基本思想

通过维护static的成员变量来记录这个唯一的实例，然后通过static的接口函数instance()；来创建这个对象，内部加入判断条件，只能创建一次，然后不要忘记屏蔽默认构造函数。

c.代码实现

//Singleton.h
#ifndef _SINGLETON_H_ 
#define _SINGLETON_H_
#include <iostream> 
using namespace std;
class Singleton 
{ 
public: 
	static Singleton* Instance();
protected:
	Singleton()=delete;     //Singleton不可以被实例化, 屏蔽构造函数
private: 
	static Singleton* _instance;
	//自动释放
	// GC 机制
    class GC
    {
    public:
        ~GC()
        {
            // 可以在这里销毁所有的资源，例如：db 连接、文件句柄等
            if (_instance!= NULL) {
                delete _instance;
                _instance= NULL;
            }
        }
        static GC gc;  // 用于释放单例
    };
};

//Singleton.cpp
#include "Singleton.h"
#include <iostream> 
using namespace std;
Singleton* Singleton::_instance = 0;      //静态成员变量初始化

Singleton::Singleton() { cout<<"Singleton...."<<endl; }

Singleton* Singleton::Instance() 
{ 
	if (_instance == 0) { 
		_instance = new Singleton();
	}
	return _instance; 
}

// 主动释放
static void DestoryInstance()
{
    if (_instance!= NULL) {
        delete _instance;
        _instance= NULL;
    }
}

客户端

#include "Singleton.h"
#include <iostream> 
using namespace std; 
Singleton::GC Singleton::GC::gc; // 程序结束自动释放
int main(int argc,char* argv[]) 
{ 
	Singleton* sgn = Singleton::Instance();
	sgn->DestoryInstance();
	return 0;
}

还有多线程问题：https://blog.csdn.net/liang19890820/article/details/61615495种有介绍

d.使用场景

如和Factory模式在一起使用，因为系统中工厂对象一般来说只要一个。

4. Builder模式

a. 问题

Builder模式的基本思想是将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

b. 模式框图

在这里插入图片描述
Product（要构造的复杂对象）：如电脑
Builder（抽象建造者）：构建产品的各个部件，抽象基类。CPU，显卡、内存条等部件组成，但不同类型的电脑如联想、Apple使用的硬件并不相同。
ConcreteBuilder（具体建造者）：实现 Builder 的接口以构造和装配该产品的具体部件，最好提供一个检索产品的接口。具体化CPU，显卡、内存条等部件。在每一步的构造过程中可以引入参数，使得经过相同的步骤创建最后得到的对象的展示不一样，也即相同的组装过程得到不同的电脑。
Director（指挥者）：使用 Builder 接口，说明构建产品的流程。一般而言director并不返回产品，只是执行buildPartA，buildPartB,…, 来一步步创建对象，通过在ConcreteBuilder里写一个返回product的接口来返回最终构建的产品。

c. 代码实现

客户端

//main.cpp
#include "Builder.h" 
#include "Product.h" 
#include "Director.h"
#include <iostream>
using namespace std;

#ifndef SAFE_DELETE
#define SAFE_DELETE(p) { if(p){delete(p); (p)=NULL;} }
#endif

int main(int argc,char* argv[]) 
{ 
	Director* pDirecror = new Director();
	ThinkPadBuilder *pTPBuilder = new ThinkPadBuilder();
	YogaBuilder *pYogaBuilder = new YogaBuilder();

	// 组装 ThinkPad、Yoga
	pDirecror->Construct(pTPBuilder);
	pDirecror->Construct(pYogaBuilder);

	// 获取组装后的电脑
    Computer *pThinkPadComputer = pTPBuilder->GetResult();
    Computer *pYogaComputer = pYogaBuilder->GetResult();

	//释放内存
	SAFE_DELETE(pThinkPadComputer);
    SAFE_DELETE(pYogaComputer);
    SAFE_DELETE(pTPBuilder);
    SAFE_DELETE(pYogaBuilder);
    SAFE_DELETE(pDirecror);
	return 0; 
}

产品：产品的各个部件也可能是抽象类，这里就简单一点，直接定义为string

// product.h
#ifndef PRODUCT_H
#define PRODUCT_H

#include <iostream>

using namespace std;

// 电脑
class Computer
{
public:
    void SetmCpu(string cpu) { m_strCpu = cpu;}
    void SetmMainboard(string mainboard) { m_strMainboard = mainboard; }
    void SetmRam(string ram) { m_strRam = ram; }
    void SetVideoCard(string videoCard) { m_strVideoCard = videoCard; }

    string GetCPU() { return m_strCpu; }
    string GetMainboard()  { return m_strMainboard; }
    string GetRam() { return m_strRam; }
    string GetVideoCard() { return m_strVideoCard; }

private:
    string m_strCpu;  // CPU
    string m_strMainboard;  // 主板
    string m_strRam;  // 内存
    string m_strVideoCard;  // 显卡
};

#endif // PRODUCT_H

创建建造者基类：创建各个电脑的部件，并定义返回构建的电脑产品的接口

// builder.h
#ifndef BUILDER_H
#define BUILDER_H

#include "product.h"

// 建造者接口，组装流程
class IBuilder
{
public:
    virtual void BuildCpu() = 0;  // 创建 CPU
    virtual void BuildMainboard() = 0;  // 创建主板
    virtual void BuildRam() = 0;  // 创建内存
    virtual void BuildVideoCard() = 0;  // 创建显卡
    virtual Computer* GetResult() = 0;  // 获取建造后的产品
};

#endif // BUILDER_H

具体的建造者：

// concrete_bulider.h
#ifndef CONCRETE_BULIDER_H
#define CONCRETE_BULIDER_H

#include "builder.h"

// ThinkPad 系列
class ThinkPadBuilder : public IBuilder
{
public:
    ThinkPadBuilder() { m_pComputer = new Computer(); }    //创建各个电脑的部件
    void BuildCpu() { m_pComputer->SetmCpu("i5-6200U"); }
    void BuildMainboard() { m_pComputer->SetmMainboard("Intel DH57DD"); }
    void BuildRam() { m_pComputer->SetmRam("DDR4"); }
    void BuildVideoCard()  { m_pComputer->SetVideoCard("NVIDIA Geforce 920MX"); }
    Computer* GetResult() { return m_pComputer; }

private:
    Computer *m_pComputer;                     //定义返回的产品为private
};

// Yoga 系列
class YogaBuilder : public IBuilder
{
public:
    YogaBuilder() { m_pComputer = new Computer(); }
    void BuildCpu() { m_pComputer->SetmCpu("i7-7500U"); }
    void BuildMainboard() { m_pComputer->SetmMainboard("Intel DP55KG"); }
    void BuildRam() { m_pComputer->SetmRam("DDR5"); }
    void BuildVideoCard()  { m_pComputer->SetVideoCard("NVIDIA GeForce 940MX"); }
    Computer* GetResult() { return m_pComputer; }

private:
    Computer *m_pComputer;
};

#endif // CONCRETE_BULIDER_H

指挥：产品构建流程，传入builder，将builder按照一定流程构建成产品

// director.h
#ifndef DIRECTOR_H
#define DIRECTOR_H

#include "builder.h"

// 指挥者
class Direcror
{
public:
    void Create(IBuilder *builder) {
        builder->BuildCpu();
        builder->BuildMainboard();
        builder->BuildRam();
        builder->BuildVideoCard();
    }
};

#endif // DIRECTOR_H

d. 优缺点

优点：建造者独立，易于扩展建造者，如在组装一个新的电脑
缺点：产品必须由相同的部件类型

Builder和Abstract Factory要实现的功能很相似，都是创建一个复杂的对象，不同的是Builder多了一个指挥者，专门用于走流程，而且director不返回产品。new builder之后，director走流程创建部件，然后通过builder自己返回产品。factory是这两个部分都是factory自己做。所以factory更灵活一点，不同factory组装流程可以不同，builder需要组装流程相同。

5. Prototype模式

a. 问题

原型模式：提供了自我复制的功能，就是说新对象的创建可以通过已有对象进行创建。

b. 模式结构

提供了一个通过已存在对象进行新对象创建的接口（Clone），Clone（）实现和具体的实现语言相关，在C++中我们将通过拷贝构造函数实现。
在这里插入图片描述

c.代码实现

客户端

// main.cpp
#include "concrete_prototype.h"

#ifndef SAFE_DELETE
#define SAFE_DELETE(p) { if(p){delete(p); (p)=NULL;} }
#endif

int main()
{
    // 孙悟空
    Prototype *pSWK = new ConcretePrototype("Qi Tian Da Sheng");

    // 克隆猴子猴孙
    Prototype *pSWK1 = pSWK->Clone();
    Prototype *pSWK2 = pSWK1->Clone();

    SAFE_DELETE(pSWK1);
    SAFE_DELETE(pSWK2);
    SAFE_DELETE(pSWK);

    getchar();

    return 0;
}

创建抽象原型

//Prototype.h
#ifndef _PROTOTYPE_H_ 
#define _PROTOTYPE_H_
class Prototype { 
public: 
	virtual ~Prototype();
	virtual Prototype* Clone() const = 0;
protected: 
	Prototype();
private:
};

创建具体原型

// concrete_prototype.h
#ifndef CONCRETE_PROTOTYPE_H
#define CONCRETE_PROTOTYPE_H

#include "prototype.h"
#include <iostream>
#include <string>

using namespace std;

// 孙悟空
class ConcretePrototype: public Prototype
{
public:
    ConcretePrototype(string name){ m_strName = name; }
    ~ConcretePrototype(){}

    // 拷贝构造函数
    ConcretePrototype(const ConcretePrototype &other) {
        m_strName = other.m_strName;
    }
    Prototype* Clone() {
        // 调用拷贝构造函数
        return new ConcretePrototype(*this);
    }
   
private:
    string m_strName;
};

#endif // CONCRETE_PROTOTYPE_H

d.优缺点

优点：如果创建新对象比较复杂，倒是可以考虑根据现有对象拷贝一个
缺点：prototype的实现很简单，关键是拷贝构造函数的实现，实现深拷贝很麻烦

知也无涯12345

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
23种设计模式之五种创建型模式

创建型模式（Creational Patterns）用于构建对象，以便它们可以从实现系统中分离出来。结构型模式（Structural Patterns）用于在许多不同的对象之间形成大型对象结构。行为型模式（Behavioral Patterns）用于管理对象之间的算法、关系和职责。目录第一部分：创建型模式1. Factory模式a. 问题b. 结构示意图c. 代码实例c. 代码实例...
复制链接

扫一扫