文章目录

前言
一、创建型模式
- 1.Factory模式
- - 功能
  - 图示
  - 实现
  - 结果
- 2. AbstractFactory模式
- - 功能
  - 图示
  - 实现
  - 结果
- 3. Singleton模式
- - 功能
  - 图示
  - 实现
  - 结果
- 4. Builder模式
- - 功能
  - 图示
  - 实现
  - 结果
- 5.Prototype模式
- - 功能
  - 图示
  - 实现
  - 结果
tips

前言

23个设计模式总结整理——创建型模式(5个)

一、创建型模式

1.Factory模式

功能

定义创建对象的接口，封装了对象的创建；让子类决定实例化哪一个类；
使得具体化类的工作延迟到了子类中

图示

实现

//Product.h
#ifndef _PRODUCT_H_
#define _PRODUCT_H_class Product {public:virtual ~Product() = 0;
protected:Product(); //屏蔽构造函数
};class ConcreteProduct:public Product {public:~ConcreteProduct();ConcreteProduct();
private:
protected:};#endif

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

//Factory.h
#ifndef _FACTORY_H_
#define _FACTORY_H_class Product;class Factory {public:virtual ~Factory() = 0;virtual Product* CreateProduct() = 0;
protected:Factory();
private:};class ConcreteFactory :public Factory {public:~ConcreteFactory();ConcreteFactory();Product* CreateProduct();
protected:
private:};#endif

//Factory.cpp
#include "Factory.h"
#include "Product.h"
#include<iostream>
using namespace std;Factory::Factory() {}Factory::~Factory() {}ConcreteFactory::ConcreteFactory() {cout << "ConcreteFactory..." << endl;
}ConcreteFactory::~ConcreteFactory() {}Product* ConcreteFactory::CreateProduct() {return new ConcreteProduct();
}

//main.cpp
#include "Factory.h"
#include "Product.h"
#include<iostream>
using namespace std;int main() {Factory* fac = new ConcreteFactory();Product* p = fac->CreateProduct();return 0;
}

结果

2. AbstractFactory模式

功能

创建一组相关或者相互依赖的对象，如游戏中，在每个关卡，要创建怪物实例，初级就创建初级怪物（有很多种类），中级创建中级怪物等。

图示

实现

//Procduct.h
#ifndef _PRODUCT_H_
#define _PRODUCT__H_class AbstractProductA {public:virtual ~AbstractProductA();
protected:AbstractProductA();
private:
};class AbstractProductB {public:virtual ~AbstractProductB();
protected:AbstractProductB();
private:
};class ProductA1 :public AbstractProductA {public:ProductA1();~ProductA1();
protected:
private:
};class ProductA2 :public AbstractProductA {public:ProductA2();~ProductA2();
protected:
private:
};class ProductB1 :public AbstractProductB {public:ProductB1();~ProductB1();
protected:
private:
};class ProductB2 :public AbstractProductB {public:ProductB2();~ProductB2();
protected:
private:
};#endif

//Product.cpp
#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() {}

//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;
protected:AbstractFactory();
private:
};class ConcreteFactory1 :public AbstractFactory {public:ConcreteFactory1();~ConcreteFactory1();AbstractProductA* CreateProductA();AbstractProductB* CreateProductB();
protected:
private:
};class ConcreteFactory2 :public AbstractFactory {public:ConcreteFactory2();~ConcreteFactory2();AbstractProductA* CreateProductA();AbstractProductB* CreateProductB();
protected:
private:
};#endif

//AbstractFactory.cpp
#include "AbstractFactory.h"
#include "Product.h"
#include<iostream>
using namespace std;AbstractFactory::AbstractFactory() {}AbstractFactory::~AbstractFactory() {}ConcreteFactory1::ConcreteFactory1() {}ConcreteFactory1::~ConcreteFactory1() {}AbstractProductA* ConcreteFactory1::CreateProductA() {return new ProductA1();
}AbstractProductB* ConcreteFactory1::CreateProductB() {return new ProductB1();
}ConcreteFactory2::ConcreteFactory2() {}ConcreteFactory2::~ConcreteFactory2() {}AbstractProductA* ConcreteFactory2::CreateProductA() {return new ProductA2();
}AbstractProductB* ConcreteFactory2::CreateProductB() {return new ProductB2();
}

//main.cpp
#include "AbstractFactory.h"
#include<iostream>
using namespace std;int main(int argc, char* argv[]) {AbstractFactory* cf1 = new ConcreteFactory1();cf1->CreateProductA();cf1->CreateProductB();AbstractFactory* cf2 = new ConcreteFactory2();cf2->CreateProductA();cf2->CreateProductB();return 0;
}

结果

3. Singleton模式

功能

保证只能创建一个对象

图示

实现

//Singleton.h
#ifndef _SINGLKETON_H_
#define _SINGLETON_H_
#include<iostream>
using namespace std;class Singleton {public:static Singleton* Instance();
protected:Singleton();
private:static Singleton* _instance;
};#endif

//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;
}

//main.cpp
#include"Singleton.h"
#include<iostream>
using namespace std;int main(int argc, char* argv[]) {Singleton* sgn = Singleton::Instance();return 0;
}

结果

4. Builder模式

功能

当我们要创建的对象很复杂是（通常由很多其他的对象组合而成），要把复杂对象的创建过程与这个对象的表示分离开来，这样做的好处是，通过一步步地进行复杂对象的构建，由于在每一步的构造过程中可以引入参数，使得经过相同的步骤创建最后得到的对象的展示不一样
例如，大学生活就是一个Builder模式的最好体验：要完成大学教育，一般将大学教育过程分成4个学期进行，因此每一学期可以看做是构建完整大学教育的一个部分教育过程，每个人经过这4年的构建过程得到最后的结果不一样，因为可能在四个阶段的构建中引入了很多的参数。（每个人的机会际遇不完全相同）

图示

实现

//Product.h
#ifndef _PRODUCT_H_
#define _PRODUCT_H_class Product {public:Product();~Product();void ProducePart();
protected:
private:
};class ProductPart {public:ProductPart();~ProductPart();ProductPart* BuildPart();
protected:
private:
};
#endif

//Product.cpp
#include "Product.h"
#include<iostream>
using namespace std;Product::Product() {ProducePart();cout << "return a product" << endl;
}Product::~Product() {}void Product::ProducePart() {cout << "build a part of product.." << endl;
}
ProductPart::ProductPart() {cout << "build product part" << endl;
}ProductPart::~ProductPart() {}ProductPart* ProductPart::BuildPart() {return new ProductPart;
}

//Builder.h
#ifndef _BUILIDER_H_
#define _BUILDER_H_
#include<iostream>
using namespace std;class Product;class Builder {public:virtual ~Builder();virtual void BuildPartA(const string& buildPara) = 0;virtual void BuildPartB(const string& buildPara) = 0;virtual void BuildPartC(const string& buildPara) = 0;virtual Product* GetProduct() = 0;
protected:Builder();
private:
};class ConcreteBuilder :public Builder {public:ConcreteBuilder();~ConcreteBuilder();void BuildPartA(const string& buildPara);void BuildPartB(const string& buildPara);void BuildPartC(const string& buildPara);Product* GetProduct();
protected:
private:
};#endif

//Builder.cpp
#include "Builder.h"
#include "Product.h"
#include<iostream>
using namespace std;Builder::Builder() {}Builder::~Builder() {}ConcreteBuilder::ConcreteBuilder() {}ConcreteBuilder::~ConcreteBuilder() {}void ConcreteBuilder::BuildPartA(const string& buildPara) {cout << "Step1:Bild PartA..." << buildPara << endl;
}void ConcreteBuilder::BuildPartB(const string& buildPara) {cout << "Step2:Build PartB..." << endl;
}void ConcreteBuilder::BuildPartC(const string& buildPara) {cout << "Step3:Build PartC..." << endl;
}Product* ConcreteBuilder::GetProduct() {BuildPartA("pre-defined");BuildPartB("pre-defined");BuildPartC("pre-defined");return new Product();
}

//Director.h
#ifndef _DIRECTOR_H_
#define _DIRECTOR_H_class Builder;class Director {public:Director(Builder* bld);~Director();void Condtruct();
protected:
private:Builder* _bld;
};#endif

//Director.cpp
#include "Director.h"
#include "Builder.h"Director::Director(Builder* bld) {_bld = bld;
}Director::~Director() {}void Director::Condtruct() {_bld->BuildPartA("user-defined");_bld->BuildPartB("user-defined");_bld->BuildPartC("user-defined");
}

//main.cpp
#include "Builder.h"
#include "Director.h"
#include "Product.h"
#include<iostream>
using namespace std;int main(int argc, char* argv[]) {Director* d = new Director(new ConcreteBuilder());d->Condtruct();return 0;
}

结果

5.Prototype模式

功能

通过已有对象创建新对象，即复制

图示

实现

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

//Prototype.cpp
#include "Prototype.h"
#include<iostream>
using namespace std;Prototype::Prototype() {}Prototype::~Prototype() {}Prototype* Prototype::Clone() const {return 0;
}ConcretePrototype::ConcretePrototype() {}ConcretePrototype::~ConcretePrototype() {}ConcretePrototype::ConcretePrototype(const ConcretePrototype& cp) {cout << "ConcretePrototype copy..." << endl;
}Prototype* ConcretePrototype::Clone() const {return new ConcretePrototype(*this);
}

//main.cpp
#include "Prototype.h"
#include<iostream>
using namespace std;int main(int argc, char* argv[]) {Prototype* p = new ConcretePrototype();Prototype* p1 = p->Clone();return 0;
}

结果

tips

next：结构型模式

常用设计模式C++实现（一）相关推荐

7 种 Javascript 常用设计模式学习笔记
7 种 Javascript 常用设计模式学习笔记由于 JS 或者前端的场景限制,并不是 23 种设计模式都常用. 有的是没有使用场景,有的模式使用场景非常少,所以只是列举 7 个常见的模式本文的 ...
打死都要记住！微服务架构的常用设计模式！
作者:duanxz 来源:cnblogs.com/duanxz/p/3514895.html 大家好,我每天都会在这里给大家分享一些干货内容(当然了,周末也要允许我休息一下哈).今天跟大家分享微服务架 ...
原型模式的应用场景_前端常用设计模式
求关注前端常见的设计模式主要有以下几种:1. 单例模式2. 工厂模式3. 策略模式4. 代理模式5. 观察者模式6. 模块模式7. 构造函数模式8. 混合模式单例模式这种设计模式的思想是确保一个 ...
Java常用设计模式————原型模式（一）
介绍原型模式(Prototype Pattern):用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象. 原型模式用于创建重复的对象,同时又能保证性能.当直接创建对象的代价比较大时,则采用 ...
模板设计模式_C常用设计模式——模板方法模式
C常用设计模式系列,我们是以策略模式开头的,因为它太简单太实用了,本篇讲的模板方法模式(Template Method),同样简单又实用.模板方法模式堪称局部代码分离关注点的神器. 代码里有个流程A, ...
23种常用设计模式的UML类图
23种常用设计模式的UML类图本文UML类图参考<Head First 设计模式>(源码)与<设计模式:可复用面向对象软件的基础>(源码)两书中介绍的设计模式与UML图. 整 ...
Spring常用设计模式--简单工厂模式
本专栏内容参考自:咕泡学院Tom老师的<Spring5核心原理与30个类手写实战>,仅作个人学习记录使用,如有侵权,联系速删. 工厂模式的由来: 在现实生活中我们都知道,原始社会自给自 ...
初学Java常用设计模式之——原型模式
声明:转载请附上原文链接提示:标题序号从3开始,是照应不同设计模式笔记发布的顺序而定的,比如,第上一篇文章初学Java常用设计模式之--工厂模式序号从2开始. 标题后面之所以加上了解,是因为相对 ...
java常用设计模式文章收集
java常用设计模式文章收集 java设计模式--接口模式 java设计模式--抽象工厂模式 java设计模式--工厂模式 Java设计模式--迭代器模式 Java设计模式--原型模式 JAVA设计模 ...
九大常用设计模式学习-装饰者模式
设计模式学习记录:一句话+代码体会设计模式. 九大常用设计模式单例模式:https://blog.csdn.net/qq_37902949/article/details/87903569 简单工厂 ...

常用设计模式C++实现（一）