结构型设计模式-单例模式/工厂模式/抽象工厂
单例模式
定义
保证一个类仅有一个实例，并提供一个该实例的全局访问点。
示例：(懒汉模式-非线程安全)
class Singleton {
public:
static Singleton * GetInstance() {
if (_instance == nullptr) {
_instance = new Singleton();
}
return _instance;
}
private:
Singleton(){}; //构造
~Singleton(){};
Singleton(const Singleton &) = delete; //拷⻉ 构造
Singleton& operator=(const Singleton&) = delete;//拷贝赋值构造
Singleton(Singleton &&) = delete;//移动构造
Singleton& operator=(Singleton &&) = delete;//移动拷贝构造
static Singleton * _instance;
};
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化
懒汉模式与饿汉模式
直观区别：饿汉：饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在了。懒汉：懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。
从性能线程上的区别：
1、线程安全：饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题。懒汉式本身是非线程安全的。
2、资源加载和性能：饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内 存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成。
而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。
如果这个创建过程很耗时，比如需要连接10000次数据库(夸张了…)，并且这个类还并不一定会被使用，那么这个创建过程就是无用的。这样的话可能懒汉模式更适合。
饿汉模式示例
#include 懒汉模式-线程安全
#include - 双重if判断可以节约资源。不用双重if的话需要在外层加锁，影响效率。
工厂模式
定义
工厂模式中实例的创建是通过封装了的工厂方法实现的，而不是常见的new操作来实现的。在工厂模式中，我们创建对象时不会对上层暴露创建逻辑，而是通过使用一个共同结构来指向新创建的对象。
简单工厂模式
每类产品需要有一个虚基类，通过接收类别参数生产具体的产品。
#include
enum ProductType
{
PRODUCT_A,
PRODUCT_B
};
// 产品基类
class Product
{
public:
virtual void Show() = 0;
};
// 产品 A
class ProductA : public Product
{
public:
void Show()
{
std::cout << "Product A." << std::endl;
}
};
// 产品 B
class ProductB : public Product
{
public:
void Show()
{
std::cout << "Porduct B." << std::endl;
}
};
// 工厂
class Factory
{
public:
Product* Create(int type)
{
switch(type)
{
case PRODUCT_A : return new ProductA; break;
case PRODUCT_B : return new ProductB; break;
default : break;
}
}
};
int main()
{
Factory *factory = new Factory();
factory->Create(PRODUCT_A)->Show();
factory->Create(PRODUCT_B)->Show();
return 0;
}
缺点：简单工厂模式将所有的创建逻辑集中在一个工厂类中。因此需要增加新的类型产品的话，除了增加继承类，还需要修改Factory类中的内容，违背了开闭原则。
工厂方法模式
与简单工厂类相比，通过虚基工厂类来添加新的类型产品。
#include
// 产品基类
class Product
{
public:
virtual void Show() = 0;
};
// 工厂基类
class Factory
{
public:
virtual Product* Create() = 0;
};
// 产品 A
class ProductA : public Product
{
public:
void Show()
{
std::cout << "Product A." << std::endl;
}
};
// 产品 B
class ProductB : public Product
{
public:
void Show()
{
std::cout << "Porduct B." << std::endl;
}
};
// 工厂 A
class FactoryA : public Factory
{
public:
Product* Create()
{
return new ProductA;
}
};
// 工厂 B
class FactoryB : public Factory
{
public:
Product* Create()
{
return new ProductB;
}
};
int main()
{
FactoryA *factoryA = new FactoryA();
FactoryB *factoryB = new FactoryB();
factoryA->Create()->Show();
factoryB->Create()->Show();
return 0;
}
需要新增类型产品时，新增我们的产品继承类，和工厂继承类就行了，符合开闭原则。
缺点：每类产品都需要新建一个工厂类。导致系统过大。
抽象工厂模式
相对于工厂方法模式中需要每类产品都需要新建一个工厂类，抽象工厂模式，是把几类产品组成一个产品组，并在一个工厂类中去做这个产品组中所有产品的构建动作。
#include
// Product A
class ProductA
{
public:
virtual void Show() = 0;
};
class ProductA1 : public ProductA
{
public:
void Show()
{
std::cout << "Product A1." << std::endl ;
}
};
class ProductA2 : public ProductA
{
public:
void Show()
{
std::cout << "Product A2." << std::endl ;
}
};
// Product B
class ProductB
{
public:
virtual void Show() = 0;
};
class ProductB1 : public ProductB
{
public:
void Show()
{
std::cout << "Product B1." << std::endl ;
}
};
class ProductB2 : public ProductB
{
public:
void Show()
{
std::cout << "Product B2." << std::endl ;
}
};
// Factory
class Factory
{
public:
virtual ProductA* CreateProductA() = 0;
virtual ProductB* CreateProductB() = 0;
};
class Factory1 : public Factory
{
public:
ProductA* CreateProductA()
{
return new ProductA1();
}
ProductB* CreateProductB()
{
return new ProductB1();
}
};
class Factory2 : public Factory
{
ProductA* CreateProductA()
{
return new ProductA2();
}
ProductB* CreateProductB()
{
return new ProductB2();
}
};
int main()
{
Factory *factoryObj1 = new Factory1();
ProductA *productObjA1 = factoryObj1->CreateProductA();
ProductB *productObjB1 = factoryObj1->CreateProductB();
productObjA1->Show();
productObjB1->Show();
Factory *factoryObj2 = new Factory2();
ProductA *productObjA2 = factoryObj2->CreateProductA();
ProductB *productObjB2 = factoryObj2->CreateProductB();
productObjA2->Show();
productObjB2->Show();
return 0;
}
缺点：如果要改我们产品组的结构的话，就需要修改我们的工厂类，这一方面就不符合开闭原则了。但在实际业务中，要避免已经确定的产品组不要再改变。
工厂模式的退化过程
当抽象工厂模式中每一个具体工厂类只创建一个产品对象，抽象工厂模式退化成工厂方法模式；当工厂方法模式中抽象工厂与具体工厂合并，提供一个统一的工厂来创建产品对象，并将创建对象的工厂方法设计为静态方法时（非虚类），工厂方法模式退化成简单工厂模式。
参考：工厂模式（C++编码）https://www.cnblogs.com/horacle/p/15494358.html