创建型设计模式
作者:Mrzhu007
日期:2018-10-27
博客地址:金色世界
了解设计模式的各种模式的设计核心思想,用核心代码的形式记录下来,备后面查看
单例模式
-
单例模式(Singleton Pattern)
-
确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例,这个类称为单例类,它提供全局访问的方法。
要点
- 某个类只能有一个实例
- 它必须自行创建
- 它必须自行向整个系统提供这个实例
一般写法
// 下面是懒汉式实现。饿汉式不用考虑多线程问题
// 后来又利用饿汉式,嵌套实现内存的自动释放
// Singleton.h
class Singleton
{
public:
static Singleton* GetInstance();
protected:
Singleton();
private:
class destr
{
public:
destr(Singleton* pInstance_) {m_pInsance = pInstacne_;}
~destr(){delete m_pInstance;}
private:
Singleton* m_pInstacne;
}
Static Singleton* m_pInstance;
Static destr
};
// Singleton.cpp
Singleton* Singleton::m_pInstance = nullptr;
Singleton* Singleton::destr(m_pInstance);
// 多线程程序要考虑多线程问题。下面不是线程安全的
Singleton* Singleton::GetInstance()
{
if(m_pInstance == nullptr)
m_pInstance = new Singleton;
return m_pInstance;
适用场景
- 系统只需要一个实例对象
- 客户调用类的单个实例只允许适用一个公共的访问点(参数、日志记录等)
简单工厂模式
定义
简单工厂模式(Simple Factory Pattern)
: 定义一个工厂类,它可以根据参数的不同返回不同类的实例,被创建的实例通常都具有共同的父类。(没有收录至四人帮中23个经典设计模式,是学习其他工厂模式的基础)
要点
思想简单:包含以下三个角色
- Factory(工厂角色):工厂类,简单工厂模式的核心。负责创建具体产品角色,返回抽象类型
- Product(抽象产品角色):创建对象的基类
- ConcreteProduct(具体产品角色):每个具体产品的定义
结构类图
// 抽象基类
class Product
{
public:
virtual void draw() = 0;
}
// 具体产品
class ProductA : public Product
{
public:
virtual void draw() { print("I'am Product A!"); }
}
class ProductB : public Product
{
public:
virtual void draw() { print("I'am Product B!"); }
}
// 工厂
class Factory
{
public:
static Product* CreateProduct(type)
{
switch(type)
{
case A:
return new ProductA;
case B:
return new ProductB;
default:
ASSERT(false);
return nullptr;
}
}
}
实际上该静态方法也可以放入抽象基类里面。根据不同参数创建不同的子类
主要缺点:违反开闭原则,及加一个产品需要修改工厂中的代码。
工厂方法模式
定义
工厂方法模式(Factory Method Pattern)
: 定义一个用于创建对象的接口,让子类决定将哪一个类实例化。让一个类的实例化延迟到其子类。又称工厂模式、虚拟构造器模式、多态工厂模式。
要点
工厂方法模式结构包含如下4个角色
- Product(抽象产品):定义产品接口
- ConcreteProduct(具体产品):每个具体产品均有一个工厂一一对应
- Factory(抽象工厂):声明了创建产品的方法。每个工厂类必须实现该接口
- ConcreteFactory(具体工厂):抽象工厂的基类,返回具体产品类型
结构类图
// 一个日志记录器
// 日志基类
class Logger
{
public:
virtual void WriteLog() = 0;
}
// 数据库记录
class DatabaseLogger : public Logger
{
public:
virtual void WriteLog() { print("数据库日志记录"); }
}
class FileLogger : public Logger
{
public:
virtual void WriteLog() { print("文件日志记录"); }
}
// 抽象工厂
class LoggerFactory
{
public:
virtual Logger* CreateLogger() = 0;
}
// 数据库日志工厂
class DatabaseLoggerFactory : public LoggerFactory
{
public:
virtual Logger* CreateLogger()
{
// 连接数据库、初始化等等
return new DatabaseLogger();
}
}
// 文件日志工厂
class FileLoggerFactory : public LoggerFactory
{
public:
virtual Logger* CreateLogger()
{
// 连接数据库、初始化等等
return new FileLogger();
}
}
使用场景
- 当一个类不知道它所必须创建的对象的类的时候
- 当一个类希望由它的子类来指定它所创建的对象的时候
- 当类将创建对象的职责委托给多个用于帮助子类中的某一个,并且你希望将哪一个帮助子类是代理者这一信息局部化的时候
抽象工厂模式
定义
抽象工厂模式(Abstract Factory Pattern)
: 提供一个创建一系列相关或相互依赖对象的接口,而无须指定他们具体的类。抽象工厂模式又称为Kit模式。它是一种对象创建型模型
要点
抽象工厂包含四个角色
- AbstractFactory(抽象工厂):声明了一组用于创建一族产品的方法。
- ConcreteFactory(具体工厂):它实现了在抽象工厂中声明的创建产品的方法。
- AbstractProduct(抽象产品):它为每种产品声明接口,定义了产品所具有的业务方法
- ConcreteProduct(具体产品):它定义具体工厂生产的具体产品对象。实现了产品接口声明的业务方法
结构类图
class AbstractProductA;
class AbstractProductB;
class AbstractFactory
{
public:
virtual AbstractProductA CreateProductA() = 0;
virtual AbstractProductB CreateProductB() = 0;
}
// 红色产品工厂
class ConcreteFactroyRed
{
public:
virtual AbstractProductA CreateProductA()
{
return new ConcreteProductARed();
}
virtual AbstractProductB CreateProductB()
{
return new ConcreteProductBRed();
}
}
// 蓝色产品工厂
class ConcreteFactroyBlue
{
public:
virtual AbstractProductA CreateProductA()
{
return new ConcreteProductABlue();
}
virtual AbstractProductB CreateProductB()
{
return new ConcreteProductBBlue();
}
}
原型模式
定义
原型模式(Prototype Pattern):
: 使用原型实例指定创建对象的种类,并且通过克隆这些原型创建新的对象。
要点
包含三个角色
- prototype(抽象原型类):声明克隆方法的接口
- Concreteprototype(具体原型类):实现抽象原型类实现的克隆方法
结构类图
class Prototype
{
public:
virtual Prototype* Clone() = 0;
}
class PrototypeA : public Prototype
{
public:
virtual Prototype* Clone()
{
return new PrototypeA(this);
}
}
建造者模式
定义
建造者模式(Builder Pattern)
: 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
要点
主要包含4个角色
- Builder(抽象建造者):定义一个产品对象的抽象接口
- ConcreteBuilder(具体建造者):实现一个具体对象的建造。把不同的配件装配好
- Product(产品角色):他是被创建的复杂对象。包含多个组成部分
- Director(指挥者):指挥者又称为导演类
结构类图
class Product;
class Builder
{
public:
virtual void buildPartA() = 0;
virtual void buildPartB() = 0;
virtual void buildPartC() = 0;
virtual Product* GetResult() = 0;
}
class ConcreteBuilder
{
public:
virtual void buildPartA() {m_pProduct->SetPartA();}
virtual void buildPartB() {m_pProduct->SetPartB();}
virtual void buildPartC() {m_pProduct->SetPartC();}
virtual Product* GetResult() { return m_pProduct;}
private:
ConcreteProduct* m_pProduct;
}
class Director
{
public:
CreateConcreteProduct(Builder* pBuild_)
{
pBuild_->buildPartA();
pBuild_->buildPartB();
pBuild_->buildPartC();
return pBuild_->GetResult();
}
}
实例
使用场景
核心在于构造一个复杂的对象。该对象有许多组件组成。每个组件有很多不同的种类。