C++单例模式与工厂模式

一、单例模式

理解C++单例模式之前，需要

参考自：C++ 静态成员变量_Little_XWB的博客-CSDN博客_c++静态成员变量

C++如何实现单例模式？_Tattoo_Welkin的博客-CSDN博客_单例模式c++实现

C++实现单例的5种方法总结_zztan的博客-CSDN博客_c++ 单例

C++类的单例模式_night boss的博客-CSDN博客_c++单例模式

C++如何用虚继承实现单例？ - 知乎

1.饿汉式

class Singleton {
private:static Singleton instance;Singleton() {}
public:static Singleton& GetInstance() {return instance;} void print() {cout << "123" << endl;}int i=1;};
Singleton Singleton::instance;//类中声明，类外定义
int main()
{Singleton::GetInstance().print();cout << Singleton::GetInstance().i << endl;return 0;
}

饿汉式在编译时便将静态对象放到全局区了。

2.懒汉式

class Singleton {
private:Singleton() {}
public:static Singleton& GetInstance() {static Singleton instance;return instance;}void print() {cout << "123" << endl;}int i = 0;
};
int main()
{Singleton::GetInstance().print();cout << Singleton::GetInstance().i << endl;return 0;
}

在这懒汉式用的是静态局部变量的方法，充分使用了静态局部变量的特点。当然也可以使用new的方式，就是比较麻烦得记得delete。

3.注册式单例

这个比较复杂些，是一种可继承的单例，需要用到模板

template<typename T>
class SingletonBase {
protected://得声明为protectedSingletonBase(){}
public:static T& GetInstance() {static T instance;return instance;}
};
class Foo :public SingletonBase<Foo> {
private:public:static void print() {cout << "123" << endl;}
};
int main()
{Foo::GetInstance().print();
}

4.多线程下的单例

参考自：多线程下的单例模式详解_若曦`的博客-CSDN博客_多线程单例模式

C++多线程单例模式_koko_TT的博客-CSDN博客_c++ 单例模式多线程

采用加锁双重判断：

#include <mutex>
using namespace std;class Singleton {
public:static Singleton* GetInstance() {if (!instance) {lock_guard<mutex> lck(mtx);if (!instance) {instance = new Singleton();}}return instance;}int i = 0;void print() {cout << "123" << endl;}
private:static Singleton* instance;static mutex mtx;Singleton(){}
};
mutex Singleton::mtx;
Singleton* Singleton::instance;
int main() {Singleton::GetInstance()->print();cout << Singleton::GetInstance()->i << endl;return 0;
}

5.补充

C#类型的单例模式可参考：c# 单例模式的实现

C# 多线程下的单例模式 - Tian_blog - 博客园

C#当中弱化了全局变量的声明与定义的概念，用C#写单例也相对简单的多，而且C#当中的锁相对C++当中的锁也方便一些，

二、工厂模式

工厂模式中对象的创建过程是我们不需要去关心的，而我们注重的是对象的实际操作，所以，我们需要分离对象的创建和操作两部分，如此，方便后期的程序扩展和维护。

参考自：

C++ 工厂模式解决什么问题？ - 明明1109 - 博客园

C++实现工厂模式_herryone123的博客-CSDN博客_c++工厂模式

1.简单工厂

1）基本要素：抽象产品类、具体产品类、一个简单工厂类

2）代码

class ItemBase {//抽象产品类
public:virtual void ItemName() = 0;virtual ~ItemBase() {};//声明析构函数为虚函数，防止内存泄漏
};
class ItemA :public ItemBase {//具体产品类A
public:void  ItemName() override{cout << "ItemA" << endl;}
};
class ItemB :public ItemBase {//具体产品类B
public:void  ItemName() override {cout << "ItemB" << endl;}
};
class ItemFactory {//简单工厂类
public:ItemBase* CreateItem(bool ItemTypeIsA) {switch (ItemTypeIsA) {case 1:return new ItemA();default:return new ItemB();}}
};
int main()
{ItemFactory itemFactory;ItemBase* itemA = itemFactory.CreateItem(1);itemA->ItemName();ItemBase* itemB = itemFactory.CreateItem(0);itemB->ItemName();
}

2.工厂方法

1）基本要素：抽象产品类、具体产品类、抽象工厂类、具体工厂类。每个具体工厂只能生产一种具体的产品

2）代码

class ItemBase {//抽象产品基类
public:virtual void ItemName() = 0;virtual ~ItemBase() {};//声明析构函数为虚函数，防止内存泄漏
};
class ItemA :public ItemBase {//具体产品类A
public:void  ItemName() override{cout << "ItemA" << endl;}
};
class ItemB :public ItemBase {//具体产品类B
public:void  ItemName() override {cout << "ItemB" << endl;}
};class ItemFactoryBase {//抽象工厂基类
public:virtual ItemBase* CreateItem() = 0;virtual ~ItemFactoryBase() {};
};
class ItemAFactory :public ItemFactoryBase {//具体工厂类A
public :ItemBase* CreateItem()override {return new ItemA();}
};
class ItemBFactory :public ItemFactoryBase {//具体工厂类B
public:ItemBase* CreateItem()override {return new ItemB();}
};
int main()
{ItemFactoryBase* itemAFactory = new ItemAFactory();ItemBase* itemA = itemAFactory->CreateItem();itemA->ItemName();ItemFactoryBase* itemBFactory = new ItemBFactory();ItemBase* itemB=itemBFactory->CreateItem();itemB->ItemName();
}

3.抽象工厂

1）基本要素：抽象产品类、具体产品类、抽象工厂类、具体工厂类。一个具体的工厂可以生产多个具体产品。

2）代码

class ShoesBase {//鞋子抽象类
public:virtual void ShoesName() = 0;virtual ~ShoesBase() {};//声明析构函数为虚函数，防止内存泄漏
};
class ShoesA :public ShoesBase {//具体产品类--鞋子A
public:void  ShoesName() override{cout << "ShoesA" << endl;}
};
class ShoesB :public ShoesBase {//具体产品类--鞋子B
public:void  ShoesName() override {cout << "ShoesB" << endl;}
};class HatBase {//帽子抽象类
public:virtual void HatName() = 0;virtual ~HatBase() {};//声明析构函数为虚函数，防止内存泄漏
};
class HatA :public HatBase {//具体产品类--帽子A
public:void  HatName() override {cout << "HatA" << endl;}
};
class HatB :public HatBase {//具体产品类--帽子B
public:void  HatName() override {cout << "HatB" << endl;}
};class FactoryBase {//抽象工厂类，可生产多种产品
public:virtual ShoesBase* CreateShoes() = 0;virtual HatBase* CreateHat() = 0;virtual ~FactoryBase() {};
};
class AFactory :public FactoryBase {//具体工厂类A，可生成所有的A类型的产品
public :ShoesBase* CreateShoes()override {return new ShoesA();}HatBase* CreateHat()override {return new HatA();}
};
class BFactory :public FactoryBase {//具体工厂类B，可生成所有的B类型的产品
public:ShoesBase* CreateShoes()override {return new ShoesB();}HatBase* CreateHat()override {return new HatB();}
};
int main()
{FactoryBase* aFactory = new AFactory();//创建A类工厂ShoesBase* shoesA = aFactory->CreateShoes();shoesA->ShoesName();HatBase* hatA = aFactory->CreateHat();hatA->HatName();FactoryBase* bFactory = new BFactory();//创建B类工厂ShoesBase* shoesB = bFactory->CreateShoes();shoesB->ShoesName();HatBase* hatB = bFactory->CreateHat();hatB->HatName();
}