A：“我想租房，價位1500左右。”

中介：“好的，我這邊有房源。什麼時候過來看看，價錢划算。”

B：“我這邊有閒置房間，想租出去，2000以上。”

中介：“可以的，我這邊有客戶。價錢好商量。”

中介---A：“房東B說了，低於2000不可以。”

中介---B：“客戶A說了，高於18000，就太高了，不想考慮。”

......

儘管講一個系統分割成所需物件，通常可以增加其複用性。但是物件間相互連線的激增，會降低其複用性。尤其是大量連結，會使得系統耦合性增加，對系統的改動，將會變得複雜和困難。這時可以考慮中介者模式。

中介者不參與實際宣告，只負責傳遞訊息。優點：集中控制，降低各個物件間的耦合。缺點：集中控制，使得中介者變得複雜。如果系統出現了多對多互動複雜的物件群時，不要急於使用該模式，而是想想是不是系統設計上存在不合理。總的來說該模式相對比較雞肋。

#pragma  once
#include<iostream>
#include<string>
using std::string;

class Country;
//中介者抽象
class UniteNations
{
public:
	virtual void declare(string messasge ,const Country* country){ }
	virtual ~UniteNations(){}
protected:

};

//具體物件
class Country
{
public:
	 Country(UniteNations * unite) :m_unite(unite)
	{

	}
	virtual~Country(){}

protected:
	UniteNations * m_unite;
};


class USA : public Country
{
public:
	USA(UniteNations * unite) :Country(unite)
	{

	}

	void declare(string msg)
	{
		m_unite->declare(msg,this);
	}

	void getmsg(string msg)
	{
		printf("USA獲得訊息：%s\n", msg.c_str());
	}

};

class IRAQ : public Country
{
public:
	IRAQ(UniteNations * unite) :Country(unite)
	{

	}

	void declare(string msg)
	{
		m_unite->declare(msg, this);
	}

	void getmsg(string msg)
	{
		printf("IRAQ獲得訊息：%s\n", msg.c_str());
	}

};

//具體中介者
class UniteSecurityCouncil :public UniteNations
{
public:
	void setUSA(USA *usa)
	{
		m_usa = usa;
	}

	void setIRAQ(IRAQ *iraq)
	{
		m_iraq = iraq;
	}


	void declare(string messasge, const Country* country)
	{
		if (country==m_usa)
		{
			m_iraq->getmsg(messasge);
		}
		else
		{
			m_usa->getmsg(messasge);
		}
	}
private:
	USA *m_usa;
	IRAQ *m_iraq;
};


int main()
{
	UniteSecurityCouncil unsc;

	USA usa(&unsc);
	IRAQ iraq(&unsc);

	unsc.setUSA(&usa);
	unsc.setIRAQ(&iraq);

	usa.declare("把石油給我，否則發動戰爭！");
	iraq.declare("艹，你以為老子威脅大的？");

	return 0;
}