设计模式观后（c++还原之十一 中介者模式）

//中介者模式
//作者举得例子：采购管理类需要库存类和销售类，才能采购
//库存类需要采购和销售类才能管理，销售需要库存和采购才能统计。
//如此的设计，造成所有的类彼此之间互相依赖！有很大的耦合性（非常错误的选择） 产生中介者模式

//先构建抽象中介者
class AbstractMediator {
protected:
	Purchase* p_purchase;
	Sale*	  p_sale;
	Stock*	  p_stock;
public:
	//中介模式，保存数据。我觉得还是用static好点。
	//局部的话，就必须传递类型对象数据。又会出现耦合现象。
	AbstractMediator() {
		p_purchase = new Purchase;
		p_stock = new Stock;
		p_sale = new Sale;
	}
	//我更愿意在这使用模板或者变长参数,鉴于这里的类型，我用int
	virtual void execute(string str, int nubmer);
};
//具体中介者
class Mediator : public AbstractMediator {
public:
	virtual void execute(string str, int nubmer) {
		if (!str.compare("buy")) {
			Buycomputer(nubmer);
		} else if (!str.compare("sell")) {
			SellComputer(nubmer);
		} else if (!str.compare("offsell")) {
			OffSell();
		} else if (!str.compare("clear")) {
			ClearStock();
		}
	}
	void Buycomputer(int number) {
		int salestatus = p_sale->GetSaleStatus();
		if (salestatus > 80) {//当销售良好时
			p_stock->Increase(number);
		} else {//销售不好时
			int buyNumber = number/2;//折半采购
			p_stock->Increase(buyNumber);
		}
	}
	void SellComputer(int number) {
		if (p_stock->GetStockNumber() < number) {//如果库存不够，就买啥！
			p_purchase->BuyIBMcomputer(number);
		}
		p_stock->Decrease(number);//够了就减
	}

private:
	void OffSell() {
		//这里应该调用，销售的api
	}
	void ClearStock() {
		//先打折销售，再拒绝采购
		p_sale->offSale();
		p_purchase->RefuseBuyIBMcomputer();
	}
};
//抽象同事类，人来管理
class AbstractColleague{
protected:
	AbstractMediator* p_meditor;
public:
	AbstractColleague(AbstractMediator* meditor) {
		p_meditor = meditor;
	}
};
class Purchase : public AbstractColleague {
public:
	Purchase(AbstractMediator* meditor)
		: AbstractColleague(meditor)
	{}
	void BuyIBMcomputer(int number) {
		cout << "buy" << number << endl;
	}
	void RefuseBuyIBMcomputer() {
		cout << "refuse";
	}
};
class Stock : public AbstractColleague
{
#define MAX_COMPUTER 1000
public:
	Stock(AbstractMediator* meditor): AbstractColleague(meditor) {}
	static int COMPUTER_NUMBER;
	void Increase(int number) {
		COMPUTER_NUMBER += number;
		cout << COMPUTER_NUMBER;
	}
	void Decrease(int number) {
		COMPUTER_NUMBER -= number;
		cout << COMPUTER_NUMBER;
	}
	int GetStockNumber() {
		return COMPUTER_NUMBER;
	}
	void ClearStock() {
		p_meditor->execute("clear", MAX_COMPUTER);
	}
};
int Stock::COMPUTER_NUMBER = 100;

class Sale : public AbstractColleague {
public:
	Sale(AbstractMediator* meditor): AbstractColleague(meditor) {}
	void SellIBMComputer(int number) {
		p_meditor->execute("sell", number);
		cout << "sell" << number;
	}
	int GetSaleStatus() {
		return 3;//这里本来是返回销售情况的。
	}
	void offSale() {
		p_meditor->execute("offsell");
	}
};

class Client {
	static void main() {
		//先构建中介者
		AbstractMediator* mediator = new AbstractMediator;
		//采购电脑
		Purchase* purch = new Purchase(mediator);
		purch->BuyIBMcomputer(100);

		Sale* psale = new Sale(mediator);
		psale->SellIBMComputer(1);
		//同理
	}
};