=======================================

一 模版方式模式

1 模版方式模式概念

  拿冲咖啡来说,泡水->冲泡咖啡->倒入顾客的杯子中->加辅料

这4个步骤虽然是充咖啡,但是这4个行为是广泛的,因为充糖水

也是这4个步骤,所以这4个步骤其实是一个模版,我们可以把这

4个行为抽象出来

2 模版方式模式代码

#include <iostream>
using namespace std;

class Make
{
public:
	virtual void water() = 0;
	virtual void tea() = 0;
	virtual void pour() = 0;
	virtual void add() = 0;

	void make()
	{
		this->water();
		this->tea();
		this->pour();
		this->add();
	}
};

class Mak_Coffee:public Make
{
public:
	virtual void water() override
	{
		cout << "烧水" << endl;
	}

	virtual void tea() override
	{
		cout << "泡" << endl;
	}

	virtual void pour() override
	{
		cout << "倒出" << endl;
	}

	virtual void add() override
	{
		cout << "加辅料" << endl;
	}

};

int main()
{
	Make *m1 = new Mak_Coffee;
	m1->make();

}

二 命令模式

1 命令模式概念

假如现在有一个Doctor类

  每个人都直接去找医生看病,但是这个医生并不会治疗鼻子怎么办

所以应该是先去填写病单,再由护士指定你去哪个医生

2 命令模式代码

#include <iostream>
#include <list>

using namespace std;

//核心类
class Doctor
{
public:
	 void treat_eyes()
	{
		cout << "treat_eyes" << endl;
	}
	 void treat_nose()
	{
		cout << "treat_nose" << endl;
	}
};

//抽象订单类
class Order
{
public:
	Order(Doctor *doc):doc(doc){}
	virtual void treat() = 0;
protected:
	Doctor *doc;
};

//让具体的订单去实现抽象订单类
class EyesOrder :public Order
{
public:
	EyesOrder(Doctor * doc) :Order(doc){}

	//实现抽象订单类的函数,但是依然是通过父类的保护成员来调用这个函数
	virtual void treat()
	{
		this->doc->treat_eyes();
	}


};

//让具体的订单去实现抽象订单类
class NoseOrder :public Order
{
public:
	NoseOrder(Doctor * doc) :Order(doc){}

	virtual void treat()
	{
		this->doc->treat_nose();
	}
};


class Nurse
{
public:
	Nurse()
	{
		list1.clear();
	}

	~Nurse()
	{
		list1.clear();
	}
	//收集订单
	void setOrder(Order *ord)
	{
		list1.push_back(ord);
	}

	//下发所有订单
	void toOreder()
	{
		for (auto it_start = list1.begin(); it_start != list1.end(); it_start++)
		{
			(*it_start)->treat();
		}
	}

private:
	list<Order *>list1;
};


int main()
{
	Nurse *nurse = new Nurse();
	nurse->setOrder(new NoseOrder(new Doctor));
	nurse->setOrder(new EyesOrder(new Doctor));
	nurse->toOreder();
}

3 命令模式额外例子

#include <iostream>
#include <vector>
using namespace std;

class FatMan
{
public:
	void fire_mutton()
	{
		cout << "fire_mutton" << endl;
	}
   
	void fire_bird()
	{
		cout << "fire_bird" << endl;
	}

};

class Order
{
public:
	Order(){};
	Order(FatMan *fat) :fat(fat){}
	virtual void toFire() = 0;
protected:
	FatMan *fat;
};

class Mutton_Order:public Order
{
public:
	virtual void toFire() 
	{
		this->fat->fire_mutton();
	}

};

class Bird_Order :public Order
{
public:
	virtual void toFire() 
	{
		this->fat->fire_bird();
	}
};

class MM
{
public:
	void setOrder(Order* ord)
	{
		this->ord.push_back(ord);
	}

	void toOrder()
	{
		for (unsigned int i = 0; i < this->ord.size(); i++)
			ord.at(i)->toFire();
	}

private:
	vector<Order*>ord;
};

int main()
{
	//创建一个老板
	FatMan *fat = new FatMan;

	//创建一个MM服务员
	MM *mm = new MM;

	//MM收集订单
	mm->setOrder(new Mutton_Order);
	mm->setOrder(new Bird_Order);

	//老板去烧烤
	mm->toOrder();

}