C++ 设计模式

//（Strategy策略模式） 
#include <iostream>

using namespace std;

#pragma once

class IStrategy
{
public:
	IStrategy(void) {}
	virtual ~IStrategy(void) {}
	virtual void Operate(void) = 0;
};


class CContext
{
public:
	CContext(IStrategy *pStrategy)
	{

		 this->m_pStrategy = pStrategy;
	}
	~CContext(void)
	{

		 delete this->m_pStrategy;
	}
	void Operate(void)
	{
		 this->m_pStrategy->Operate();
	}
private:
	IStrategy *m_pStrategy;
};

class CBackDoor :public IStrategy
{
public:
	CBackDoor(void)
	{

	}
	~CBackDoor(void)
	{

	}
	void Operate(void)
	{
		 cout << "找乔国老帮忙，让吴国太给孙权施加压力" << endl;
	}
};

class CGivenGreenLight :public IStrategy
{
public:
	CGivenGreenLight(void) {}
	~CGivenGreenLight(void) {}
	void Operate(void)
	{
		cout << "求吴国太开个绿灯，放行！" << endl;
	}
};

class CBlockEnemy :
	public IStrategy
{
public:
	CBlockEnemy(void) {}
	~CBlockEnemy(void) {}
	void Operate(void)
	{
		 cout << "孙夫人断后，挡住追兵" << endl;
	}
};

//（Proxy代理模式） 
#include <iostream>

using namespace std;

#pragma once



class IKindWomen
{
public:
	IKindWomen(void) {}
	virtual ~IKindWomen(void){}
	virtual void MakeEyesWithMan() = 0;
	virtual void HappyWithMan() = 0;
};

class CWangPo :public IKindWomen
{
public:
	CWangPo(IKindWomen *pKindWomen)
	{
		this->m_pKindWomen = pKindWomen;
	}
	~CWangPo(void)
	{
		delete m_pKindWomen;
	}
	void HappyWithMan(void)
	{
		   this->m_pKindWomen->HappyWithMan();
	}
	void MakeEyesWithMan(void)
	{
		this->m_pKindWomen->MakeEyesWithMan();
	}
private:
	IKindWomen *m_pKindWomen;
};

class CPanJinLian :
	public IKindWomen
{
public:
	CPanJinLian(void) {}
	~CPanJinLian(void) {}
	void HappyWithMan(void)
	{
		 cout << " CPanJinLian==>HappyWithMan... ... " << endl;
	}
	void MakeEyesWithMan(void)
	{
		 cout << " CPanJinLian==>MakeEyesWithMan " << endl;
	}
};

class CJiaShi :
	public IKindWomen
{
public:
	CJiaShi(void) {}
	~CJiaShi(void) {}
	void HappyWithMan(void)
	{
		cout << " CJiaShi==>HappyWithMan... ... " << endl;
	}
	void MakeEyesWithMan(void)
	{
		cout << " CJiaShi==>MakeEyesWithMan " << endl;
	}
};

//（Multition多例模式） 

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

class ServiceUdp
{
public:
	static ServiceUdp *MakeInstace(int nu);
	 int DeleteInstace();

private:
	ServiceUdp(int nu){ num = nu;}
	~ServiceUdp(){}

	int num;
	static map<int,ServiceUdp*> ServiceUdpMap;

};

//（Factory Method工厂方法模式） 

#include <iostream>

using namespace std;

#pragma once

class IHuman
{
public:
	IHuman(void)
	{
	}
	virtual ~IHuman(void)
	{
	}
	virtual void Laugh() = 0;
	virtual void Cry() = 0;
	virtual void Talk() = 0;
};

class CYellowHuman :
	public IHuman
{
public:
	CYellowHuman(void)
	{

	}
	~CYellowHuman(void)
	{

	}
	void Laugh()
	{
		cout << "黄色人种会大笑，幸福呀！" << endl;
	}
	void Cry()
	{
		 cout << "黄色人种会哭" << endl;
	}
	void Talk()
	{
		cout << "黄色人种会说话，一般说的都是双字节" << endl;
	}
};

class CWhiteHuman :
	public IHuman
{
public:
	CWhiteHuman(void)
	{

	}
	~CWhiteHuman(void)
	{

	}
	void Laugh()
	{
		 cout << "白色人种会大笑，侵略的笑声" << endl;
	}
	void Cry()
	{
		cout << "白色人种会哭" << endl;
	}
	void Talk()
	{
		 cout << "白色人种会说话，一般都是单字节" << endl;
	}
};

class IHumanFactory
{
public:
	IHumanFactory(void)
	{
	}
	virtual ~IHumanFactory(void)
	{
	}
	virtual IHuman * CreateHuman() = 0;
};

class CYellowHumanFactory :
	public IHumanFactory
{
public:
	CYellowHumanFactory(void)
	{

	}
	~CYellowHumanFactory(void)
	{

	}
	virtual IHuman * CreateHuman(void)
	{
		 return new CYellowHuman();
	}
};

class CWhiteHumanFactory :
	public IHumanFactory
{
public:
	CWhiteHumanFactory(void) {}
	~CWhiteHumanFactory(void) {}
	virtual IHuman * CreateHuman(void)
	{
		return new CWhiteHuman(); 
	}
};

//（Facade门面模式） 

//简单说，就是将复杂的逻辑封装起来，对外公开简单的接口，由客户程序调用。这里举了一个发送邮件的例子，我们理解为电子邮件吧，
//普通的邮件应该不需要告诉邮局，我们写的信件内容（呵呵有点较真了）。

#pragma once

#include <iostream>

using std::string;

class ILetterProcess
{
public:
	ILetterProcess(void) {}
	virtual ~ILetterProcess(void) {}
	virtual void WriteContext(string context) = 0;
	virtual void FillEnvelope(string address) = 0;
	virtual void LetterIntoEnvelope() = 0;
	virtual void SendLetter() = 0;
};

class CLetterProcessImpl :
	public ILetterProcess
{
public:
	CLetterProcessImpl(void) {}
	~CLetterProcessImpl(void) {}

	void WriteContext(string context) 
	{
		 cout << "填写信的内容... ..." << endl;
	}
	void FillEnvelope(string address)
	{
		  cout << "填写收件人地址及姓名... ..." << endl;
	}
	void LetterIntoEnvelope()
	{
		cout << "把信放到信封中..." << endl;
	}
	void SendLetter()
	{
		 cout << "邮递信件..." << endl;
	}
};

class CLetterPolice
{
public:
	CLetterPolice(void) {}
	~CLetterPolice(void) {}
	void CheckLetter(ILetterProcess *pLetterProcess)
	{
		//检查信件，此处省略一万字。
		return;
	}
};

class CModenPostOffice
{
public:
	CModenPostOffice(void) 
	{
		this->m_pLetterProcess = new CLetterProcessImpl();
		this->m_pLetterPolice = new CLetterPolice();
	}
	~CModenPostOffice(void) 
	{
		delete m_pLetterProcess;
		delete m_pLetterPolice;
	}
	void SendLetter(string context, string address)
	{
		//帮忙写信
		m_pLetterProcess->WriteContext(context);
		//写好信封
		m_pLetterProcess->FillEnvelope(address);
		//警察要检查信件了
		m_pLetterPolice->CheckLetter(m_pLetterProcess);
		//把信放到信封中
		m_pLetterProcess->LetterIntoEnvelope();
		//邮递信件
		m_pLetterProcess->SendLetter();
	}
private:
	ILetterProcess *m_pLetterProcess;
	CLetterPolice *m_pLetterPolice;
};

#pragma once
#include <iostream>

using namespace  std;

//产品接口
class IHuman
{
public:

	IHuman(void)
	{
	}

	virtual ~IHuman(void)
	{
	}

	virtual void Laugh() = 0;
	virtual void Cry() = 0;
	virtual void Talk() = 0;
	virtual void Sex() = 0;
};

class CYellowHuman :public IHuman
{
public:
	CYellowHuman(void)
	{
	}
	~CYellowHuman(void)
	{
	}
	void Laugh()
	{
		cout << "黄色人种会大笑，幸福呀！" << endl;
	}
	void Cry()
	{
		cout << "黄色人种会哭" << endl;
	}
	void Talk()
	{
		cout << "黄色人种会说话，一般说的都是双字节" << endl;
	}
	virtual void Sex() = 0;
};

class CYellowFemaleHuman :
	public CYellowHuman
{
public:
	CYellowFemaleHuman(void)
	{
	}
	~CYellowFemaleHuman(void)
	{
	}
	void Sex()
	{
		cout << "该黄种人的性别为女..." << endl;
	}
};

class CXiaoYellowFemaleHuman :public CYellowFemaleHuman
{
public:
	CXiaoYellowFemaleHuman(){}
	~CXiaoYellowFemaleHuman(){}
	void Age()
	{
		cout << "小黄种女人..." << endl;
	}
};
class CYellowMaleHuman :
	public CYellowHuman
{
public:
	CYellowMaleHuman(void)
	{
	}
	~CYellowMaleHuman(void)
	{
	}
	void Sex()
	{
		cout << "该黄种人的性别为男..." << endl;
	}
};

class CWhiteHuman :
	public IHuman
{
public:
	CWhiteHuman(void)
	{
	}
	~CWhiteHuman(void)
	{
	}
	void Laugh()
	{
		cout << "白色人种会大笑，侵略的笑声" << endl;
	}
	void Cry()
	{
		cout << "白色人种会哭" << endl;
	}
	void Talk()
	{
		cout << "白色人种会说话，一般都是单字节" << endl;
	}
	virtual void Sex() = 0;
};

class CWhiteFemaleHuman :
	public CWhiteHuman
{
public:
	CWhiteFemaleHuman(void)
	{
	}
	~CWhiteFemaleHuman(void)
	{
	}
	void Sex()
	{
		cout << "该白种人的性别为女..." << endl;
	}
};

class CWhiteMaleHuman :
	public CWhiteHuman
{
public:
	CWhiteMaleHuman(void)
	{
	}
	~CWhiteMaleHuman(void)
	{
	}
	void Sex()
	{
		cout << "该白种人的性别为男..." << endl;
	}
};

class CBlackHuman :
	public IHuman
{
public:
	CBlackHuman(void)
	{
	}
	~CBlackHuman(void)
	{
	}
	void Laugh()
	{
		cout << "黑人会笑" << endl;
	}
	void Cry()
	{
		cout << "黑人会哭" << endl;
	}
	void Talk()
	{
		cout << "黑人可以说话，一般人听不懂" << endl;
	}

	virtual void Sex() = 0;
};

class CBlackFemaleHuman :
	public CBlackHuman
{
public:
	CBlackFemaleHuman(void)
	{
	}
	~CBlackFemaleHuman(void)
	{
	}
	void Sex()
	{
		cout << "该黑种人的性别为女..." << endl;
	}
};

class CBlackMaleHuman :
	public CBlackHuman
{
public:
	CBlackMaleHuman(void)
	{
	}
	~CBlackMaleHuman(void)
	{
	}
	void Sex()
	{
		cout << "该黑种人的性别为男..." << endl;
	}
};

class IHumanFactory
{
public:
	IHumanFactory(void)
	{
	}
	virtual ~IHumanFactory(void)
	{
	}
	virtual IHuman * CreateYellowHuman() = 0;
	virtual IHuman * CreateWhiteHuman() = 0;
	virtual IHuman * CreateBlackHuman() = 0;
};

template<class T>
class CStandardHumanFactory :
	public IHumanFactory
{
public:
	CStandardHumanFactory(void)
	{
	}
	~CStandardHumanFactory(void)
	{
	}
	T * CreateHuman()
	{
		return new T;
	}
};


template<class T>
class CMaleHumanFactory :
	public CStandardHumanFactory<T>
{
public:
	CMaleHumanFactory(void);
	~CMaleHumanFactory(void);
	T * CreateYellowHuman();
	T * CreateWhiteHuman();
	T * CreateBlackHuman();
};

template<class T>
CMaleHumanFactory<T>::CMaleHumanFactory(void)
{
}
template<class T>
CMaleHumanFactory<T>::~CMaleHumanFactory(void)
{
}
template<class T>
T * CMaleHumanFactory<T>::CreateYellowHuman()
{
	return CreateHuman();
}
template<class T>
T * CMaleHumanFactory<T>::CreateWhiteHuman()
{
	return CreateHuman();
}
template<class T>
T * CMaleHumanFactory<T>::CreateBlackHuman()
{
	return CreateHuman();
}

template<class T>
class CXiaoMaleHumanFactory :
	public CStandardHumanFactory<T>
{
public:
	CXiaoMaleHumanFactory(void);
	~CXiaoMaleHumanFactory(void);
	T * CreateYellowHuman();
	T * CreateWhiteHuman();
	T * CreateBlackHuman();
};

template<class T>
CXiaoMaleHumanFactory<T>::CXiaoMaleHumanFactory(void)
{
}
template<class T>
CXiaoMaleHumanFactory<T>::~CXiaoMaleHumanFactory(void)
{
}
template<class T>
T * CXiaoMaleHumanFactory<T>::CreateYellowHuman()
{
	return CreateHuman();
}
template<class T>
T * CXiaoMaleHumanFactory<T>::CreateWhiteHuman()
{
	return CreateHuman();
}
template<class T>
T * CXiaoMaleHumanFactory<T>::CreateBlackHuman()
{
	return CreateHuman();
}

template<class T>
class CFemaleHumanFactory :
	public CStandardHumanFactory<T>
{
public:
	CFemaleHumanFactory(void)
	{
	}
	~CFemaleHumanFactory(void)
	{
	}
	T * CreateYellowHuman()
	{
		return CreateHuman();
	}
	T * CreateWhiteHuman()
	{
		return CreateHuman();
	}
	T * CreateBlackHuman()
	{
		return CreateHuman();
	}
};

void DoIt()
{

	IHumanFactory *p = new CFemaleHumanFactory<CXiaoYellowFemaleHuman>();
    CXiaoYellowFemaleHuman *pp = dynamic_cast<CXiaoYellowFemaleHuman*>(p->CreateYellowHuman());
	pp->Age();
	
	
	IHumanFactory *pFemaleHumanFactory = new CFemaleHumanFactory<CYellowFemaleHuman>();
	IHuman *pYellowFemaleHuman = pFemaleHumanFactory->CreateYellowHuman();
	pYellowFemaleHuman->Cry();
	pYellowFemaleHuman->Laugh();
	pYellowFemaleHuman->Talk();
	pYellowFemaleHuman->Sex();
	
	delete pYellowFemaleHuman;
	delete pFemaleHumanFactory;

	IHumanFactory *pMaleHumanFactory = new CMaleHumanFactory<CYellowMaleHuman>();
	IHuman *pYellowMaleHuman = pMaleHumanFactory->CreateYellowHuman();
	pYellowMaleHuman->Cry();
	pYellowMaleHuman->Laugh();
	pYellowMaleHuman->Talk();
	pYellowMaleHuman->Sex();
	delete pYellowMaleHuman;
	delete pMaleHumanFactory;
}