C++ 设计模式

1.简单工厂模式

	使用一个工厂去创建所需要的类
	水果工厂：工厂类、抽象水果类、具体水果类
	简单工厂模式增加新的水果需要修改工厂类内部内容
	违反了开闭原则，对于扩展是开放的，但是对于修改是封闭的
	引出工厂模式

2.工厂模式

	工厂模式在简单工厂上添加新的抽象工厂
	抽象工厂->具体工厂  抽象水果->具体水果类
	新增水果时需要增加新的具体工厂，每种水果一个工厂

3.单例模式

1.将构造函数私有化
2.增加静态的私有的当前对象指针
3.提供静态对外接口
4.类外初始化
懒汉式：
	在第一次调用时创建对象（多线程需要加锁）
饿汉式：
	在系统开始运行即创建对象

//懒汉式
class singleInstance_lazy
{
private:
	singleInstance_lazy() { cout << "懒汉构造" << endl; };
public:
	static singleInstance_lazy * getSingleInstance()
	{
		if (instace == NULL)
		{
			instace =  new singleInstance_lazy;
		}
		return  instace;

	}
private:
	static singleInstance_lazy* instace;
};

singleInstance_lazy* singleInstance_lazy::instace =NULL;

//饿汉式
class singleInstance_hungry
{
private:
	singleInstance_hungry() { cout << "饿汉构造" << endl; };
public:
	static singleInstance_hungry * getSingleInstance()
	{
		return instace;
	}
private:
	static singleInstance_hungry* instace;
};

singleInstance_hungry* singleInstance_hungry::instace = new singleInstance_hungry;

4.代理模式

使用一个代理类来调用类的方法，在代理类中添加身份验证方法。
将代理类 和被代理类都继承同一个抽象方法，将被代理类作为代理类中的一个变量
使用时创建代理类的对象，使用代理类的方法调用被代理类

5.外观模式

新建一个类，类中将其他需要统一启动的类作为成员变量。添加启动方法，调用所有启动。
类似于：电脑主机，按下开机键，电源、主板、显卡都会启动...

6.适配器模式

已经写好的接口不符合新的需求，将接口转换为需要的目标接口。
新增一个目标类，将已有的类作为他的成员变量，再实现调用

7.模板方法模式

父类不在具体实现，但是增加一个函数将执行顺序确定。
冲泡饮料  ：
	父类-> 煮水 冲泡 倒入杯中 加料 
		新增make函数，将四种方法的调用顺序确定。
	子类：分别实现添加不同的料

8.策略模式

一个人可以开各种各样的车，策略模式就将抽象的车做为人的成员变量，提供set方法，
设置具体的车，实现可以t替换使用各种各样的车。	

9.命令模式

将具体的请求封装成一个对象
命令实现处理类 ： 各种命令的处理方法
抽象命令类  ：抽象命令方法处理
具体命令类：将命令实现处理类作为成员变量，实现抽象处理方法调用具体的处理请求
命令请求者	

10.观察者模式

当一个对象被修改时，则会自动通知依赖它的对象
抽象观察者
具体观察者
观察目标：
	 成员变量： 
		抽象观察者链表
	方法： 
		通知观察者的 增加观察者  删除观察者

11.装饰模式

在已有的物体上增加新的东西
抽象物体类
具体物体
抽象装饰类（装饰器）：继承抽象物体
具体装饰类 

#include <iostream>
#include <string>

using namespace std;

//抽象蛋糕
class AbstractCake
{
public:
	virtual void show() = 0;
public:
	string std;
};

//具体蛋糕
class Cake : public AbstractCake
{
public:
	Cake(){
		std = "基础蛋糕";
	};
	virtual void show()
	{
		cout << std << endl;
	}
};

//抽象装饰类
class Abstractadd : public AbstractCake
{
public:
	Abstractadd(AbstractCake *  c){
		this->cake = c;
	};
	virtual void show() {};
public:
	AbstractCake * cake;
};

//具体装饰类
class apple : public Abstractadd
{
public:
	apple(AbstractCake *cake) : Abstractadd(cake) {};
	virtual void show()
	{
		this->addMaterial();
		cout << this->std<< endl;
	};
	void addMaterial()
	{
		this->std  = this->cake->std + "+苹果" ;
	}
};

class pear : public Abstractadd
{
public:
	pear(AbstractCake *cake) :Abstractadd(cake) {};
	virtual void show()
	{
		this->addMaterial();
		cout << this->std << endl;
	};
	void addMaterial()
	{
		this->std = this->cake->std + "+梨";
	}
};

int main()
{	
	AbstractCake * c = new Cake;
	c->show();
	c = new apple(c);
	c->show();
	c = new pear(c);
	c->show();
}

-----------------------------------------------------------------------------------------------------
https://blog.csdn.net/qq_28779503/category_10364077.html?spm=1001.2014.3001.5482