c++ 常用设计模式——个人理解

设计模式是什么？顾名思义就是写代码的一种风格，一种便于理解，一种便于扩展，是代码简洁，具有阅读性的一种书写方式！所以在前辈的基础上去总结，逐渐的形成了设计模式，今天我就个人写代码几年的基础上去谈一谈个人对于设计模式的理解

1、工厂模式

当我们一提到设计模式，想必大多数人第一个想到的便是工厂模式，因为在我们生活中或者说写代码的情景中都太常见不过了，那我们常见的工厂模式又分为哪几种呢？简单工厂模式，抽象工厂模式，工厂方法模式

1.1简单工厂模式

简单工厂的怎么去理解呢 ？ 假设有iPhone11,iPhone10,iPhone9 需要在中国销售，那就需要中国的代工厂进行生产,现在有欧菲光等工厂可以生产，那我们现在就可以理解为欧菲光这个工厂目前三种产品都可以生产，但是具体要生产那种产品不知道，所以这里产品我们就可以用C++的多态,建立一个虚拟产品，等到真正需要生产产品的时候我们再去绑定(这就是c++多态的动态绑定)，真正意义上去实现工厂生产多元化的产品

uml图：

对于简单设计模式的结构图，我们可以很清晰的看到它的组成：
1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
3) 具体产品角色：工厂类所创建的对象就是此角色的实例。
简单设计模式存在的目的很简单：定义一个用于创建对象的接口。

缺点：对修改不封闭，新增加产品您要修改工厂。违法了鼎鼎大名的开闭法则（OCP）。

代码：

enum PhoneType
{
	iPhone_11,
	iPhone_10,
	iPhone_9
};
class ProductPhone
{
public:
	virtual ~ProductPhone() {};  // 基类虚析构
	virtual void CreateProduct() = 0; // 产品公有方法
};

class ProductIphone_11 :public ProductPhone // 苹果11
{
public:
	void CreateProduct() 
	{
		cout << "create iPhone_11" << endl;
	}
};
class ProductIphone_10 :public ProductPhone  // 苹果10
{
public:
	void CreateProduct()
	{
		cout << "create iPhone_10" << endl;
	}
};
class ProductIphone_9 :public ProductPhone  // 苹果9
{
public:
	void CreateProduct()
	{
		cout << "create iPhone_9" << endl;
	}
};
class Factory
{
public:
	Factory();
	virtual ~Factory();

	ProductPhone * CreateIphone(PhoneType type)
	{
		switch (type)
		{
		case iPhone_11:
			return new ProductIphone_11();
		case iPhone_10:
			return new ProductIphone_10();
		case iPhone_9:
			return new ProductIphone_9();
		default:
			break;
		}
	}
};

1.2抽象工厂模式

抽象工厂怎么去理解呢？可以理解为工厂抽象了，同时产品也抽象了，既然是抽象，咱们就可以都理解为多态，不同的工厂去生产不同的产品，这就构成了工厂多元化，产品多元化

uml图：

对于上面的结构图，可以看出抽象工厂模式，比前两者更为的复杂和一般性，抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。
抽象工厂模式：给客户端提供一个接口，可以创建多个产品族中的产品对象 ，而且使用抽象工厂模式还要满足一下条件：
1)系统中有多个产品族，而系统一次只可能消费其中一族产品。
2)同属于同一个产品族的产品以其使用。

抽象工厂模式的组成（和工厂方法模式一样）：
1)抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。
4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。
代码：

// 产品基类 轿车的基类 长安的轿车 吉利的轿车
class ProductCar
{
public:
	virtual ~ProductCar() {}; // 基类虚析构 防止内存泄漏
	virtual void CreateCar() = 0; // 产品类公有方法
};
class ProductCar_Changan:public ProductCar
{
public:
	virtual void CreateCar()
	{
		cout << "create Car ChangAn" << endl;
	}
};
class ProductCar_JiLi:public ProductCar
{
public:
	virtual void CreateCar()
	{
		cout << "create Car Jili" << endl;
	}
};

// 公交车的基类 实例有 比亚迪公交车 上汽公交车
class ProductBus
{
public:
	virtual ~ProductBus() {};
	virtual void CreateBus() = 0; // 生产公交车
};
class ProductBus_BYD:public ProductBus
{
public: 
	virtual void CreateBus()
	{
		cout << "create Bus BYD" << endl;
	}
};
class ProductBus_SQ :public ProductBus
{
public:
	virtual void CreateBus()
	{
		cout << "create Bus SQ" << endl;
	}
};

// 工厂的基类 实例呢又有A B两个代工厂
class AbstractFactory
{
public:
	AbstractFactory();
	virtual ~AbstractFactory();
	virtual ProductCar * CreateSmallCar() = 0; // 生产小轿车
	virtual ProductBus * CreateBigBus() = 0;   // 生产公交车
};

// A工厂生产 长安的轿车 和 生产BYD的公交车
class AbstractFactory_A :public AbstractFactory
{
public:
	virtual ProductCar * CreateSmallCar()
	{
		return new ProductCar_Changan();
	}
	virtual ProductBus * CreateBigBus()
	{
		return new ProductBus_BYD();
	}
};

// B工厂生产 吉利的轿车和上汽的公交车
class AbstractFactory_B :public AbstractFactory
{
public:
	virtual ProductCar * CreateSmallCar()
	{
		return new ProductCar_JiLi();
	}
	virtual ProductBus * CreateBigBus()
	{
		return new ProductBus_SQ();
	}
};

1.3工厂方法模式

什么可以称之为工厂方式模式，如上面的抽象模式一样，工厂是抽象的，产品也是抽象的，但是工厂不再具有同时生产多种产品的流水线了，而是专一的生产某种产品

uml图：

 其实这才是真正的工厂模式，简单工厂模式只能算是“坑爹版”的工厂模式。我们能很容易看出工厂方法模式和简单工厂模式的区别之处。工厂方法模式的应用并不是只是为了封装对象的创建，而是要把对象的创建放到子类中实现：Factory中只是提供了对象创建的接口，其实现将放在Factory的子类ConcreteFactory中进行。
对于工厂方法模式的组成：
1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。
4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。

缺点：每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的处理器核，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。
代码：

class ProductCar
{
public:
	virtual ~ProductCar() {}; // 基类虚析构 防止内存泄漏
	virtual void CreateCar() = 0; // 产品类公有方法
};
class ProductCar_Changan:public ProductCar
{
public:
	virtual void CreateCar()
	{
		cout << "create Car ChangAn" << endl;
	}
};
class ProductCar_JiLi:public ProductCar
{
public:
	virtual void CreateCar()
	{
		cout << "create Car Jili" << endl;
	}
};
// 工厂的基类 实例呢又有长安 吉利两个代工厂
class AbstractFactory
{
public:
	AbstractFactory();
	virtual ~AbstractFactory();
	virtual ProductCar * CreatePuduct() = 0;
};
// 长安代工厂
class AbstractFactory_ChangAn :public AbstractFactory
{
public:
	virtual ProductCar * CreatePuduct()
	{
		return new ProductCar_Changan();
	}
};
// 吉利代工厂
class AbstractFactory_Jili :public AbstractFactory
{
public:
	virtual ProductCar * CreatePuduct()
	{
		return new ProductCar_Changan();
	}
};

2.0 单例模式

因为在设计或开发中，肯定会有这么一种情况，一个类只能有一个对象被创建，如果有多个对象的话，可能会导致状态的混乱和不一致。这种情况下，单例模式是最恰当的解决办法。它有很多种实现方式，各自的特性不相同，使用的情形也不相同。今天要实现的是常用的三种，分别是饿汉式、懒汉式和多线程式。

2.1懒汉式单例

懒汉模式的访问方式又具有线程不安全的状态，正常情况下，如果线程A调用getInstance()时，将m_instance 初始化了，那么线程B再调用getInstance()时，就不会再执行new了，直接返回之前构造好的对象。然而存在这种情况，线程A执行m_instance = new Singleton()还没完成，这个时候m_instance仍然为nullptr，线程B也正在执行m_instance = new Singleton()，这是就会产生两个对象，线程A和B可能使用的是同一个对象，也可能是两个对象，这样就可能导致程序错误，同时，还会发生内存泄漏。

class CSingleTance
{
public:
	static CSingleTance* GetInstance()
	{
		if (m_pInstance == nullptr)
		{
			return new CSingleTance();
		}
	}
	
private:
	CSingleTance(); // 构造函数私有化
	CSingleTance(const CSingleTance& obj);
	static CSingleTance* m_pInstance;
};
CSingleTance* CSingleTance::m_pInstance = nullptr;

3.0