目录

0. 设计原则

1. 组件协作

策略模式Strategy 

模板方法模式TemplateMethod

观察者模式Observer

2. 单一职责

装饰者模式Decorator

桥接模式Birdge

3. 对象创建

工厂方法模式FactoryMethod

 抽象工厂模式AbstractFactory

原型模式Prototype

构造器模式Builder

4. 对象性能

单例模式Singleton

享元模式Flyweight

5. 接口隔离

门面模式Facade

代理模式Proxy​编辑

适配器模式Adapter

中介者模式Mediator

6. 状态变化

状态模式State

备忘录模式Memento

7. 数据结构

组合模式Component

迭代器模式Iterator

职责链模式ChainOfResponsibility

8. 行为变化

命令行模式Command

访问器模式Visitor

9. 领域规则

解释器模式

0. 设计原则

【单一职责原则】实现类要职责单一

1. 应该有且仅有一个原因引起类的变更（一个接口或一个类只有一个原则，它就只负责一件事）。

【里氏替换原则】不要破坏继承体系

1. 子类型必须能够替换掉它们的基类型。

【依赖倒置原则】面向抽象编程

1. 高层模块不应该依赖低层模块，两者都应该依赖抽象；
2. 抽象不应该依赖实现细节，实现细节应该依赖抽象。

【接口隔离原则】设计接口要精简单一

1. 客户端不应该依赖它不需要的接口；
2. 类间的依赖关系应该建立在最小的接口上。

【迪米特法则】要降低耦合度

1. 只与朋友进行通信。

【开闭原则】对修改关闭，对扩展开放（解耦、单一、高内聚就是开闭原则的精神纲领）

【优先使用组合，而不是类继承】

1. 类继承通常为“白箱复用”，对象组合通常为“黑箱复用”；
2. 继承在某种程度上破坏了封装性，子类父类耦合度高；
3. 对象组合则只要求被组合的对象具有良好定义的接口，耦合度低。

【封装变化点】

1. 使用封装来创建对象之间的分界层，让设计师可以在分界层的一侧进行修改，而不会对另一侧产生不良的影响，从而实现层次间的松耦合。

【针对接口编程，而不是针对实现编程】

1. 不将变量类型声明为某一个特定的具体类，而是声明为某个接口；
2. 客户程序无需获知对象的具体类型，只需要知道对象所具有的接口；
3. 减少系统中各部分的依赖关系，从而实现“高内聚，松耦合”的类型设计方案。

#include 
#include 
using namespace std;

#define DELETE_PTR( ptr ) { if( ptr ) { delete ptr; ptr = nullptr; } }
#define PRINT_FUNC printf("execute func = %sn" , __FUNCTION__);
#define PRINT_INFO( str )  printf("info = %sn" , str);

//#define DELETE_PTR( ptr ) ( if( ptr ) { delete ptr; ptr = nullptr; } ) //error
//#define PRINT_FUNC; printf("execute file:%stline:%dt 
//             date:%sttime:%st 
//			 func:%sn" ,
//             __FILE__,__LINE__ ,    
//             __DATE__,__TIME__ , __FUNCTION__)

1. 组件协作

• 策略模式Strategy 

//

namespace StrategyPattern {

	//抽象算法类
	class IStrategy {
	public:
		virtual ~IStrategy() { PRINT_FUNC; }

		virtual void AlgorithmInterface() = 0;
	};

	//具体算法类
	class ConcreteStratergyA : public IStrategy {
	public:
		virtual ~ConcreteStratergyA() { PRINT_FUNC; }

		virtual void AlgorithmInterface() override
		{
			PRINT_FUNC;
		}
	};

	class ConcreteStratergyB : public IStrategy {
	public:
		virtual ~ConcreteStratergyB() { PRINT_FUNC; }

		virtual void AlgorithmInterface() override
		{
			PRINT_FUNC;
		}
	};

	

	class Context {
	public:
		Context(IStrategy* stratergy) : m_pStratergy(stratergy) {}
		virtual ~Context()
		{
			PRINT_FUNC;
			DELETE_PTR(m_pStratergy)
		}

		void ContextInterface()
		{
			m_pStratergy->AlgorithmInterface();
		}
	private:
		IStrategy* m_pStratergy;
	};

	void executeStratergy()
	{
		IStrategy* stratergy = new ConcreteStratergyA;
		Context* context = new Context(stratergy);
		context->ContextInterface();

		delete context;
		context = nullptr;


		stratergy = new ConcreteStratergyB;
		context = new Context(stratergy);
		context->ContextInterface();

		delete context;
		context = nullptr;
	}
}

• 模板方法模式TemplateMethod

//

#include  // typeid need
namespace TemplateMethodPattern {

	class AbstractClass
	{
	public:
		void Execute() //Template Method
		{
			Step1();
			Step2();
		}

	protected:
		virtual void Step1() = 0;
		virtual void Step2() = 0;
	};

	class ConcreteClassA : public AbstractClass
	{
	protected:
		virtual void Step1() override
		{
			
			PRINT_FUNC;
			
		}

		virtual void Step2() override
		{
			
			PRINT_FUNC;
			
		}
	};

	class ConcreteClassB : public AbstractClass
	{
	public:
	protected:
		virtual void Step1() override
		{
			//
			PRINT_FUNC;
			//
		}

		virtual void Step2() override
		{
			//
			PRINT_FUNC;
			//
		}
	};


	void executeTemplateMethod()
	{
		AbstractClass* a = new ConcreteClassB;
		a->Execute();
	}
}

• 观察者模式Observer

//

#include 
namespace ObserverPattern {
	class IObserver
	{
	public:
		virtual void Update(const string& info) = 0;
	};

	class ObserverA : public IObserver {
	public:
		virtual void Update(const string& info) override
		{
			PRINT_FUNC;
			PRINT_INFO(info.c_str());
		}
	};

	class ObserverB : public IObserver {
	public:
		virtual void Update(const string& info) override
		{
			PRINT_FUNC;
			PRINT_INFO(info.c_str());
		}
	};

	class Subject
	{
	public:
		void AddObserver(IObserver* obs)
		{
			auto iter = find(m_Observers.begin(), m_Observers.end(), obs);
			if (iter != m_Observers.end())
			{
				return;//已存在
			}

			m_Observers.push_back(obs);
		}

		void DelObserver(IObserver* obs)
		{
			//m_Observers.remove(obs);

			auto iter = find(m_Observers.begin(), m_Observers.end(), obs);
			if (iter != m_Observers.end())
			{
				m_Observers.erase(iter);
			}
			else {
				PRINT_INFO("没有该对象");
			}
		}

		void Notify(const string& info)
		{
			PRINT_FUNC;
			PRINT_INFO(info.c_str());

			for (auto obs : m_Observers)
			{
				obs->Update(info);
			}
		}

	private:
		list m_Observers;
	};

	void executeObserver()
	{
		Subject* subject = new Subject;

		IObserver* observer = new ObserverA;

		subject->AddObserver(observer);
		subject->DelObserver(observer);

		observer = new ObserverB;
		subject->AddObserver(observer);

		subject->Notify(string("今晚吃大餐"));
	}
}

2. 单一职责

• 装饰者模式Decorator

//

namespace DecoratorPattern {
	class AbstractComponent {
	public:
		virtual void Operation() = 0;
	};
	class ConcreteComponent : public AbstractComponent
	{
	public:
		virtual void Operation() override
		{
			PRINT_INFO("具体组件...");
			PRINT_FUNC;
		}
	};

	class Decorator : public AbstractComponent {
	public:
		Decorator(AbstractComponent* comp) : m_pAbsComp(comp) {}
		virtual ~Decorator()
		{
			DELETE_PTR(m_pAbsComp);
		}
		virtual void Operation() override
		{
			PRINT_FUNC;
			m_pAbsComp->Operation();
		}
	private:
		AbstractComponent* m_pAbsComp;
	};

	class ConcreteDecoratorA : public Decorator
	{
	public:
		ConcreteDecoratorA(AbstractComponent* comp) : Decorator(comp) {}
		virtual void Operation() override
		{
			PRINT_INFO("装饰A...");
			PRINT_FUNC;
			Decorator::Operation();
		}
	};

	class ConcreteDecoratorB : public Decorator
	{
	public:
		ConcreteDecoratorB(AbstractComponent* comp) : Decorator(comp) {}
		virtual void Operation() override
		{
			PRINT_INFO("装饰B...");
			PRINT_FUNC;
			Decorator::Operation();
		}

	};
	void executeDecorator()
	{
		//单纯组件
		AbstractComponent* comp = new ConcreteComponent;
		comp->Operation();
		cout << endl;

		//用A装饰组件
		Decorator* decoratorA = new ConcreteDecoratorA(comp);
		decoratorA->Operation();
		cout << endl;

		//用A+B装饰组件
		Decorator* decoratorB = new ConcreteDecoratorB(decoratorA);
		decoratorB->Operation();
	}

}

• 桥接模式Birdge

//

namespace BridgePattern {
	class AbstractImplementor {
	public:
		virtual void Operation() = 0;
	};

	class ConcreteImplementorA : public AbstractImplementor {
	public:
		virtual void Operation()
		{
			PRINT_FUNC;
		}
	};

	class ConcreteImplementorB : public AbstractImplementor {
	public:
		virtual void Operation()
		{
			PRINT_FUNC;
		}
	};

	class AbstractBusiness {
	public:
		AbstractBusiness(AbstractImplementor* imp) : m_pImp(imp) {}
		virtual ~AbstractBusiness()
		{
			DELETE_PTR(m_pImp);
		}

		virtual void Operation() = 0;

	protected:
		AbstractImplementor* m_pImp;
	};

	class ConcreteBusinessA : public AbstractBusiness {
	public:
		ConcreteBusinessA(AbstractImplementor* imp) : AbstractBusiness(imp) {}

		virtual void Operation()
		{
			PRINT_FUNC;
			m_pImp->Operation();
		}
	};

	class ConcreteBusinessB : public AbstractBusiness {
	public:
		ConcreteBusinessB(AbstractImplementor* imp) : AbstractBusiness(imp) {}

		virtual void Operation()
		{
			PRINT_FUNC;
			m_pImp->Operation();
		}
	};

	void executeBridge()
	{
		AbstractImplementor* m_pImp = new ConcreteImplementorA;
		AbstractBusiness* business = new ConcreteBusinessA(m_pImp);
		business->Operation();

		cout << endl;
		m_pImp = new ConcreteImplementorB;
		business = new ConcreteBusinessA(m_pImp);
		business->Operation();
	}
}

3. 对象创建

• 工厂方法模式FactoryMethod

//

namespace FactoryMethod {
	class AbstractProduct {
	public:
		virtual void Operation() = 0;
	};

	class ConcreteProductA : public AbstractProduct
	{
	public:
		virtual void Operation()
		{
			PRINT_INFO("产品A......");
		}
	};

	class ConcreteProductB : public AbstractProduct
	{
	public:
		virtual void Operation()
		{
			PRINT_INFO("产品B......");
		}
	};

	class AbstractFactory
	{
	public:
		void AnOperation()
		{
			AbstractProduct* product = CreateProduct();
			product->Operation();
		}
	protected:
		virtual AbstractProduct* CreateProduct() = 0;
	};

	class ConcreteFactoryA : public AbstractFactory
	{
	public:
		virtual AbstractProduct*  CreateProduct()
		{
			return new ConcreteProductA;
		}
	};

	class ConcreteFactoryB : public AbstractFactory
	{
	public:
		virtual AbstractProduct*  CreateProduct()
		{
			return new ConcreteProductB;
		}
	};


	void executeFactoryMethod()
	{
		AbstractFactory* factory = new ConcreteFactoryA;
		factory->AnOperation();

		cout << endl;
		factory = new ConcreteFactoryB;
		factory->AnOperation();
	}
}

•  抽象工厂模式AbstractFactory

//

namespace AbstractFactory
{
	class AbstractProductA
	{
	public:
		virtual void Operation() = 0;
	};

	class AbstractProductB
	{
	public:
		virtual void Operation() = 0;
	};

	class ProductPartA1 : public AbstractProductA
	{
	public:
		virtual void Operation()
		{
			PRINT_INFO("产品零部件A1......");
		}
	};

	class ProductPartA2 : public AbstractProductA
	{
	public:
		virtual void Operation()
		{
			PRINT_INFO("产品零部件A2......");
		}
	};

	class ProductPartB1 : public AbstractProductB
	{
	public:
		virtual void Operation()
		{
			PRINT_INFO("产品零部件B1......");
		}
	};

	class ProductPartB2 : public AbstractProductB
	{
	public:
		virtual void Operation()
		{
			PRINT_INFO("产品零部件B2......");
		}
	};

	class AbstractFactory
	{
	public:
		void AnOperation()
		{
			m_ProductA = CreateProductA();
			m_ProductA->Operation();
			m_ProductB = CreateProductB();
			m_ProductB->Operation();

		}
		virtual AbstractProductA* CreateProductA() = 0;
		virtual AbstractProductB* CreateProductB() = 0;
	protected:
		AbstractProductA* m_ProductA;
		AbstractProductB* m_ProductB;
	};

	//工厂A生产产品A，由产品A零部件1+产品A零部件2组成
	class ConcreteFactroy1 : public AbstractFactory
	{
	public:
		virtual AbstractProductA* CreateProductA()
		{
			return new ProductPartA1;
		}
		virtual AbstractProductB* CreateProductB()
		{
			return new ProductPartB1;
		}
	};


	//工厂B生产产品B，由产品B零部件1+产品B零部件2组成
	class ConcreteFactroy2 : public AbstractFactory
	{
	public:
		virtual AbstractProductA* CreateProductA()
		{
			return new ProductPartA2;
		}
		virtual AbstractProductB* CreateProductB()
		{
			return new ProductPartB2;
		}
	};

	void executeAbstractFactory()
	{
		PRINT_INFO("工厂1......");
		AbstractFactory* factory = new ConcreteFactroy1;
		factory->AnOperation();

		PRINT_INFO("工厂2......");
		factory = new ConcreteFactroy2;
		factory->AnOperation();
	}
}

• 原型模式Prototype

//

namespace Prototype {

	class IPrototype
	{
	public:
		virtual IPrototype* Clone() = 0;
	};

	class ConcretePrototype1 : public IPrototype
	{
	public:
		ConcretePrototype1()
		{
			cout << "无参构造缓函数：";
			PRINT_FUNC;
		}

		ConcretePrototype1(const ConcretePrototype1& prototype)
		{
			cout << "拷贝构造缓函数：";
			PRINT_FUNC;
		}

		virtual IPrototype* Clone() override
		{
			return new ConcretePrototype1(*this);
		}
	};

	class ConcretePrototype2 : public IPrototype
	{
	public:
		ConcretePrototype2()
		{
			cout << "无参构造缓函数：";
			PRINT_FUNC;
		}

		ConcretePrototype2(const ConcretePrototype2& prototype)
		{
			cout << "拷贝构造缓函数：";
			PRINT_FUNC;
		}

		virtual IPrototype* Clone() override
		{
			return new ConcretePrototype2(*this);
		}
	};

	class Client {
	public:
		Client(IPrototype* prototype) : m_pPrototype(prototype) {}
		virtual ~Client()
		{
			DELETE_PTR(m_pPrototype);
		}

		IPrototype* Operation()
		{
			return m_pPrototype->Clone();
		}
	private:
		IPrototype* m_pPrototype;
	};

	void executePrototype()
	{
		IPrototype* Prototype1Obj = new ConcretePrototype1;
		IPrototype* clonePrototype1Obj = Prototype1Obj->Clone();

		IPrototype* Prototype2Obj = new ConcretePrototype2;
		IPrototype* clonePrototype2Obj = Prototype2Obj->Clone();
	}
}

• 构造器模式Builder

//

namespace Builder
{
	class IHouse {
	public:
		IHouse()
		{
			PRINT_FUNC;
		}
		virtual ~IHouse() { PRINT_FUNC; }

		virtual void BuildRoof() = 0;
		virtual void BuildWall() = 0;
		virtual void BuildWindow() = 0;
		virtual void BuildDoor() = 0;
		virtual void BuildGround() = 0;
	};

	class IBuilder
	{
	public:
		IBuilder() { PRINT_FUNC; }
		virtual ~IBuilder()
		{
			PRINT_FUNC;
		}

		virtual IHouse* CreateHouse()
		{
			IHouse* house = GetHouse();
			PRINT_INFO("开始组装...");
			BuildRoof(house);
			BuildWall(house);
			BuildWindow(house);
			BuildDoor(house);
			BuildGround(house);

			return house;
		}

		virtual IHouse* GetHouse() = 0;

	private:
		virtual void BuildRoof(IHouse* house) = 0;
		virtual void BuildWall(IHouse* house) = 0;
		virtual void BuildWindow(IHouse* house) = 0;
		virtual void BuildDoor(IHouse* house) = 0;
		virtual void BuildGround(IHouse* house) = 0;
	};

	///
	class StoneHouse : public IHouse
	{
	public:
		StoneHouse()
		{
			PRINT_FUNC;
		}
		virtual ~StoneHouse()
		{
			PRINT_FUNC;
		}
		virtual void BuildRoof()
		{
			cout << "t生成人字形屋顶...";
			PRINT_FUNC;
		}
		virtual void BuildWall()
		{
			cout << "t生成四面围墙...";
			PRINT_FUNC;
		}
		virtual void BuildWindow()
		{
			cout << "t生成四个窗户...";
			PRINT_FUNC;
		}
		virtual void BuildDoor()
		{
			cout << "t生成两扇门...";
			PRINT_FUNC;
		}
		virtual void BuildGround()
		{
			cout << "t生成木地面...";
			PRINT_FUNC;
		}
	};

	class StoneBuilder : public IBuilder
	{
	public:
		StoneBuilder() { PRINT_FUNC; }
		virtual ~StoneBuilder()
		{
			PRINT_FUNC;
		}

		virtual void BuildRoof(IHouse* house) override
		{
			house->BuildRoof();
		}
		virtual void BuildWall(IHouse* house) override
		{
			house->BuildWall();
		}
		virtual void BuildWindow(IHouse* house) override
		{
			house->BuildWindow();
		}
		virtual void BuildDoor(IHouse* house) override
		{
			house->BuildDoor();
		}
		virtual void BuildGround(IHouse* house) override
		{
			house->BuildGround();
		}

		virtual IHouse* GetHouse() override
		{
			return new StoneHouse;
		}
	};

	
	class WoodHouse : public IHouse
	{
	public:
		WoodHouse()
		{
			PRINT_FUNC;
		}
		virtual ~WoodHouse()
		{
			PRINT_FUNC;
		}
		virtual void BuildRoof()
		{
			cout << "t生成人字形屋顶...";
			PRINT_FUNC;
		}
		virtual void BuildWall()
		{
			cout << "t生成四面围墙...";
			PRINT_FUNC;
		}
		virtual void BuildWindow()
		{
			cout << "t生成四个窗户...";
			PRINT_FUNC;
		}
		virtual void BuildDoor()
		{
			cout << "t生成两扇门...";
			PRINT_FUNC;
		}
		virtual void BuildGround()
		{
			cout << "t生成木地面...";
			PRINT_FUNC;
		}
	};

	class WoodBuilder : public IBuilder
	{
	public:
		WoodBuilder() { PRINT_FUNC; }
		virtual ~WoodBuilder()
		{
			PRINT_FUNC;
		}

		virtual void BuildRoof(IHouse* house) override
		{
			house->BuildRoof();
		}
		virtual void BuildWall(IHouse* house) override
		{
			house->BuildWall();
		}
		virtual void BuildWindow(IHouse* house) override
		{
			house->BuildWindow();
		}
		virtual void BuildDoor(IHouse* house) override
		{
			house->BuildDoor();
		}
		virtual void BuildGround(IHouse* house) override
		{
			house->BuildGround();
		}

		virtual IHouse* GetHouse() override
		{
			return new WoodHouse;
		}
	};


	class Director {
	public:
		Director(IBuilder* builder) : m_pBuilder(builder) {}
		virtual ~Director()
		{
			delete(m_pBuilder);
		}

		IHouse* Construct()
		{
			return m_pBuilder->CreateHouse();
		}

	private:
		IBuilder* m_pBuilder;
	};

	void executeBuilder()
	{
		IBuilder* builder = new StoneBuilder;

		Director* director = new Director(builder);
		IHouse* house = director->Construct();

		DELETE_PTR(director);
		DELETE_PTR(house);

		cout << "n--------------------------------------" << endl;
		builder = new WoodBuilder;

		director = new Director(builder);
		house = director->Construct();

		DELETE_PTR(director);
		DELETE_PTR(house);
	}
}

4. 对象性能

• 单例模式Singleton

//

#include 
mutex g_mutex;
namespace Singleton {

	class LogSingleton {
	public:
		virtual ~LogSingleton() {
			//DELETE_PTR(m_Log);
		}

		//采用双检查锁
		static LogSingleton* GetInstance()
		{
			if (nullptr == m_Log)
			{
				g_mutex.lock();
				if (nullptr == m_Log)
				{
					m_Log = new LogSingleton;
				}
				g_mutex.unlock();
			}
			return m_Log;
		}

		void printInfo(const string& str)
		{
			cout << str.c_str() << endl;
		}
	private:
		LogSingleton() {}
		static LogSingleton* m_Log;
	};

	LogSingleton* LogSingleton::m_Log = nullptr;
	void executeSingleton()
	{
		LogSingleton::GetInstance()->printInfo("World");
		LogSingleton::GetInstance()->printInfo(",");
		LogSingleton::GetInstance()->printInfo("Hello");
		LogSingleton::GetInstance()->printInfo("!");
	}
}

• 享元模式Flyweight

//

#include 

5. 接口隔离

• 门面模式Facade

//

namespace Facade {

	class SubSystemOne {
	public:
		void MethodOne() { PRINT_FUNC; }
	};

	class SubSystemTwo {
	public:
		void MethodTwo() { PRINT_FUNC; }
	};

	class SubSystemThree {
	public:
		void MethodThree() { PRINT_FUNC; }
	};

	class SubSystemFour {
	public:
		void MethodFour() { PRINT_FUNC; }
	};

	class SubSystemFive {
	public:
		void MethoFive() { PRINT_FUNC; }
	};

	class Facade {
	public:
		void Method1()
		{
			m_SubSys1.MethodOne();
			m_SubSys2.MethodTwo();
			m_SubSys5.MethoFive();
		}
		void Method2()
		{
			m_SubSys1.MethodOne();
			m_SubSys2.MethodTwo();
			m_SubSys3.MethodThree();
			m_SubSys4.MethodFour();
			m_SubSys5.MethoFive();
		}
	private:
		SubSystemOne m_SubSys1;
		SubSystemTwo m_SubSys2;
		SubSystemThree m_SubSys3;
		SubSystemFour m_SubSys4;
		SubSystemFive m_SubSys5;
	};

	void executeFacade()
	{
		Facade* facade = new Facade;
		facade->Method1();
		facade->Method2();

		DELETE_PTR(facade);
	}
}

代理模式Proxy

//

namespace Proxy {
	class Subject
	{
	public:
		virtual void Operation() = 0;
	};

	//真实目标A
	class RealSubjectA : public Subject{
	public:
		virtual void Operation()
		{
			PRINT_FUNC;
		}
	};
	//真实目标B
	class RealSubjectB : public Subject {
	public:
		virtual void Operation()
		{
			PRINT_FUNC;
		}
	};

	//代理A，可以访问具体目标类A
	class ProxyA : public Subject {
	public:
		ProxyA()
		{
			m_pRealSubject = new RealSubjectA;
		}

		virtual ~ProxyA()
		{
			DELETE_PTR(m_pRealSubject);
		}

		virtual void Operation()
		{
			m_pRealSubject->Operation();
		}

	private:
		Subject* m_pRealSubject;
	};

	//代理B，可以访问具体目标类B
	class ProxyB : public Subject {
	public:
		ProxyB()
		{
			m_pRealSubject = new RealSubjectB;
		}

		virtual ~ProxyB()
		{
			DELETE_PTR(m_pRealSubject);
		}

		virtual void Operation()
		{
			m_pRealSubject->Operation();
		}

	private:
		Subject* m_pRealSubject;
	};

	void executeProxy()
	{
		Subject* proxy = new ProxyA();
		proxy->Operation();

		proxy = new ProxyB();
		proxy->Operation();
	}
}

• 适配器模式Adapter

//

namespace Adapter {
	class Target {//目标
	public:
		virtual void Request() = 0;
	};

	class Adaptee {//被适配者
	public:
		void SpecificRequest()
		{
			PRINT_INFO("执行特殊请求...");
		}
	};

	class Adapter : public Target{//适配器和被适配器的对应关系明确的
	public:
		Adapter()
		{
			m_pAdaptee = new Adaptee;//紧耦合
		}
		virtual ~Adapter()
		{
			DELETE_PTR(m_pAdaptee);
		}
		void Request() override
		{
			PRINT_INFO("1.使用对象适配器...");
			m_pAdaptee->SpecificRequest();
		}

	private:
		Adaptee* m_pAdaptee;//看得出Adapter是对象适配器
	};

	class ClassAdapter : public Target,public Adaptee {//看得出Adapter是类适配器（不推荐）,适配器和被适配器的对应关系明确的
	public:
		void Request() override
		{
			PRINT_INFO("2.使用类适配器...");
			this->SpecificRequest();
		}

	private:
		Adaptee* m_pAdaptee;//看得出Adapter是对象适配器
	};
	
	void executeAdapter()
	{
		Target* adapter = new Adapter();
		adapter->Request();

		adapter = new ClassAdapter();
		adapter->Request();

		delete adapter;
	}
}

• 中介者模式Mediator

//

namespace Mediator {
	class Colleague;
	class IMediator {
	public:
		virtual void SendMsg(const string& msg,Colleague* colleague) = 0;
	};

	class Colleague {
	public:
		Colleague(IMediator* mediator) : m_pMediator(mediator){}

		virtual void ReceiveMsg(const string& msg) = 0;
		virtual void SendMsg(const string& msg) = 0;
	protected:
		IMediator* m_pMediator;
	};

	class ConcreteColleague1 : public Colleague {
	public:
		ConcreteColleague1(IMediator* mediator) : Colleague(mediator)
		{

		}
		virtual void ReceiveMsg(const string& msg)
		{
			string sMsg = "同事1：收到信息，";
			sMsg.append(msg);
			PRINT_INFO(sMsg.c_str());
		}
		virtual void SendMsg(const string& msg)
		{
			m_pMediator->SendMsg(msg,this);
		}
	};

	class ConcreteColleague2 : public Colleague {
	public:
		ConcreteColleague2(IMediator* mediator) : Colleague(mediator)
		{

		}
		virtual void ReceiveMsg(const string& msg)
		{
			string sMsg = "同事2：收到信息，";
			sMsg.append(msg);
			PRINT_INFO(sMsg.c_str());
		}
		virtual void SendMsg(const string& msg)
		{
			m_pMediator->SendMsg(msg, this);
		}
	};

	class ConcreteMediator : public IMediator {
	public:
		void SetColleague1(ConcreteColleague1* colleague)
		{
			m_pColleague1 = colleague;
		}
		void SetColleague2(ConcreteColleague2* colleague)
		{
			m_pColleague2 = colleague;
		}
		virtual void SendMsg(const string& msg, Colleague* colleague) override
		{
			if (m_pColleague1 == colleague)
			{
				m_pColleague2->ReceiveMsg(msg);
			}
			else if (m_pColleague2 == colleague)
			{
				m_pColleague1->ReceiveMsg(msg);
			}
		}
	private:
		ConcreteColleague1* m_pColleague1;
		ConcreteColleague2* m_pColleague2;
	};

	void executeMediator()
	{
		ConcreteMediator* mediator = new ConcreteMediator;
		ConcreteColleague1* colleague1 = new ConcreteColleague1(mediator);
		ConcreteColleague2* colleague2 = new ConcreteColleague2(mediator);

		mediator->SetColleague1(colleague1);
		mediator->SetColleague2(colleague2);

		colleague1->SendMsg("我好饿...");
		colleague2->SendMsg("我现在还好，待会去吃饭...");
	}
}

6. 状态变化

• 状态模式State

//

namespace State {
	//enum LightState
	//{
	//	ON,
	//	OFF
	//};

	class Context;
	class IState {
	public:
		virtual ~IState()
		{
			PRINT_FUNC;
		}
		virtual void Handle(Context* context) = 0;
	};

	class Context {
	public:
		
		virtual ~Context() {
			PRINT_FUNC;
			DELETE_PTR(m_pState);
		}

		void SetState(IState* state)
		{
			DELETE_PTR(m_pState);
			m_pState = state;
		}

		virtual void Request()
		{
			m_pState->Handle(this);
		}

	private:
		IState* m_pState;
	};

	class ONState;
	class OFFState : public IState {
	public:
		~OFFState() {
			PRINT_FUNC;
		}
		virtual void Handle(Context* context) override;
	}; 
	
	class ONState : public IState {
	public:
		~ONState() {
			PRINT_FUNC;
		}
		virtual void Handle(Context* context) override;
	};

	void OFFState::Handle(Context* context)
	{
		PRINT_INFO("天亮了，把灯关闭");
		IState* state = new ONState;
		context->SetState(state);//状态切换：从OFF切到ON
	}

	void ONState::Handle(Context* context)
	{
		PRINT_INFO("晚上了，把灯打开");
		IState* state = new OFFState;
		context->SetState(state);//状态切换：从ON切到OFF
	}

	void executeState()
	{
		Context* context = new Context;
		IState* state = new ONState;
		context->SetState(state);
		context->Request();
		context->Request();
		context->Request();
		context->Request();

		delete context;
	}
}

• 备忘录模式Memento

//

namespace Memento {
	class Memento {
	public:
		Memento(const string& state)
		{
			m_State = state;
		}
		virtual ~Memento()
		{
			PRINT_FUNC;
		}

		void SetState(const string& state)
		{
			m_State = state;
		}

		string GetState() const
		{
			return m_State;
		}
	private:
		string m_State;
	};

	class Caretaker {
	public:
		Caretaker(Memento* m) : m_Memento(m){}
		virtual ~Caretaker()
		{
			PRINT_FUNC;
			DELETE_PTR(m_Memento);
		}

		Memento* GetMemento()
		{
			return m_Memento;
		}
	private:
		Memento* m_Memento;
	};

	class Originator {
	public:
		Originator():m_State("Empty State")
		{

		}
		virtual ~Originator()
		{
			PRINT_FUNC;
		}

		void SetState(const string& state)
		{
			m_State = state;
		}

		void PrintState()
		{
			PRINT_INFO(m_State.c_str());
		}

		void SetMemento(const Memento& m)
		{
			m_State = m.GetState();
		}

		Memento* CreateMemento()
		{
			return new Memento(m_State);
		}
	private:
		string m_State;
	};

	void executeMemento()
	{
		//原发器
		Originator* originator = new Originator;
		originator->SetState("state01");
		originator->PrintState();

		//实例化管理者，创建一个备忘录存储在管理者中
		Caretaker* c = new Caretaker(originator->CreateMemento());

		//更改原发器的状态名称
		originator->SetState("state02");
		originator->PrintState();

		originator->SetMemento(*(c->GetMemento()));
		originator->PrintState();

		delete c;
		delete originator;
	}
}

7. 数据结构

• 组合模式Component

//

#include 
namespace Component {
	class Component {
	public:
		Component(const string& tag): m_sTag(tag)
		{

		}
		virtual void Operation() = 0;

	protected:
		string m_sTag;
	};

	class Composite : public Component {
	public:
		Composite(const string& tag) : Component(tag)
		{

		}
		virtual void Operation()
		{
			PRINT_INFO(m_sTag.c_str());
			PRINT_FUNC;
			for (auto iter = m_listComp.begin() ; iter != m_listComp.end(); ++iter)
			{
				(*iter)->Operation();
			}
		}
		virtual void Add(Component* comp)
		{
			m_listComp.push_back(comp);
		}
		virtual void Remove(Component* comp)
		{
			auto iter = find(m_listComp.begin(), m_listComp.end(), comp);
			m_listComp.erase(iter);
		}
		virtual Component* GetChild(const int& i)
		{
			Component* comp = m_listComp.at(i);
			return comp;
		}

	private:
		vector m_listComp;
	};

	class Leaf : public Component {
	public:
		Leaf(const string& tag) : Component(tag)
		{

		}
		virtual void Operation() override
		{
			PRINT_INFO(m_sTag.c_str());
			PRINT_FUNC;
		}
	};

	void executeComponent()
	{
		Composite* root = new Composite("Root");

		Composite*leftComp = new Composite("LeftComp");
		Composite*RightComp = new Composite("RightComp");

		Component* leftLeaf1 = new Leaf("leftLeaf1");
		Component* leftLeaf2 = new Leaf("leftLeaf2");
		Component* leftLeaf3 = new Leaf("leftLeaf3");


		root->Add(leftComp);
		root->Add(RightComp);

		leftComp->Add(leftLeaf1);
		leftComp->Add(leftLeaf2);
		leftComp->Add(leftLeaf3);

		root->Operation();
	}
}

• 迭代器模式Iterator

//

namespace Iterator {
	void executeIterator()
	{

	}
}

• 职责链模式ChainOfResponsibility

//

namespace ChainOfResponsibility {
	class Handler {
	public:
		Handler(Handler* successor = nullptr):m_pSuccessor(successor)
		{

		}
		virtual ~Handler() { DELETE_PTR(m_pSuccessor); }
		virtual void HandlerRequest() = 0;

	protected:
		Handler* m_pSuccessor;
	};

	class ConcreteHandler1 : public Handler
	{
	public:
		ConcreteHandler1(Handler* successor = nullptr) : Handler(successor)
		{

		}
		virtual void HandlerRequest()
		{
			if (nullptr != m_pSuccessor)
			{
				m_pSuccessor->HandlerRequest();
			}
			else {
				PRINT_INFO("ConcreteHandler1::HandlerRequest");
			}
		}
	};

	class ConcreteHandler2 : public Handler
	{
	public:
		ConcreteHandler2(Handler* successor = nullptr) : Handler(successor)
		{

		}

		virtual void HandlerRequest()
		{
			if (nullptr != m_pSuccessor)
			{
				m_pSuccessor->HandlerRequest();
			}
			else {
				PRINT_INFO("ConcreteHandler2::HandlerRequest");
			}
		}
	};

	void executeChainOfResponsibility()
	{
		Handler* handler1 = new ConcreteHandler1;
		Handler* handler2 = new ConcreteHandler2(handler1);


		handler2->HandlerRequest();
	}
}

8. 行为变化

• 命令行模式Command

• 访问器模式Visitor

9. 领域规则

• 解释器模式