论设计模式的培养与形成

论设计模式的培养与形成
2010年06月03日
　　策略模式：
　　是指一组算法封装到独立的类中，这些类抽象出公共接口，从而使这些类可以互相代替。
　　即设计一个抽象类。
　　其他具体方法继承此类，从而实现方法的多态性。
　　比如图书的折扣有多样性。
　　那么可通过策略模式的方法来实现。
　　class CBookStrategy
　　{
　　public:
　　virtual double GetDiscount()=0;
　　CBookStategy()
　　{
　　}
　　}
　　//无折扣
　　class CNonDiscount:public CBookStrategy
　　{
　　private:
　　int m_BookCount;
　　double m_BookPrice;
　　publc:
　　CNonDiscount(int BookCount,double BookPrice)
　　{
　　m_BookCount=BookCount;
　　m_BookPrice=BookPrice;
　　}
　　virtual double GetDiscount()
　　{
　　return m_BookCount* m_BookPrice;
　　}
　　//百分比折扣，多输入一个百分比的数据
　　class CPerDiscount:public CBookStrategy
　　{
　　private:
　　int m_BookCount;
　　double m_BookPrice;
　　double m_Percent;
　　public:
　　double GetPercent()
　　{
　　return m_Percent;
　　}
　　void SetPercent(double Percent)
　　{
　　m_Percent=Percent;
　　}
　　CperDisount(int BookCount,double BookPrice,double Percent)
　　{
　　m_BookCount=BookCount;
　　m_BookPrice=BookPrice;
　　m_Percent=Percent;
　　}
　　virtual double GetDiscount()//虚拟函数用来加工处理返回所需要的值。
　　{
　　return m_BookCount*m_BookPrice*m_Percent;
　　}
　　//具体价格折扣
　　int main()
　　{
　　CBookStrategy* pStrategy;
　　//无折扣
　　pStrategy=new CNonDiscount(2,35);
　　coutGetDiscount()Cry();
　　delete pAnimal;//清除内存缓冲区
　　...
　　return 0;
　　}
　　}
　　
　　3.抽象工厂模式
　　抽象工厂模式是在工厂方法模式基础上产生的，它向客户提供一个接口，使得客户不必指定产品的具体类型就可以创建多种产品对象。
　　//定义抽象类
　　class CAnimal
　　{
　　protected:
　　int m_Weight;//重量
　　public:
　　virtual void Cry()=0;
　　}
　　class CPlant
　　{
　　protected:
　　int m_Height;
　　public:
　　virtual void Grow()=0;
　　};
　　//定义具体工厂类
　　class CFish:public CAnimal
　　{
　　public:
　　virtual void Cry()
　　{
　　countCreateObj();
　　pPlant1=pFactory1->CreatePlant();
　　pAnimal2=pFactory2->CreateObj();
　　pPlant2=pFactory2->CreatePlant();
　　pAnimal1->Cry();
　　pAnimal2->Cry();
　　pPlant1->Grow();
　　pPlant2->Grow();
　　delete pAnimal1;
　　delete pAnimal2;
　　delete pPlant1;
　　delete pPlant2;
　　return 0;
　　}
　　4.观察者模式：
　　观察者模式是一种行为模式，它定义了一种一对多的依赖关系，让多个观察者对象监听一个主题对象，当主题对象的状态改变时，他将通知所有观察者对象。
　　观察者模式包含4个角色，分别为抽象主题角色，抽象观察者角色，具体主题角色，和具体观察者角色。抽象观察者角色提供了一个接口（存虚方法），在观察者对象获得通知时执行更新操作；具体主题角色负责实现抽象主题角色的多个接口，并且定义有聚合对象，用于包含多个观察者对象；具体观察者角色负责实现抽象观察者角色提供的更新接口。
　　class CObserver//定义抽象观察者角色
　　{
　　public:
　　virtual UpdateOpt()=0;
　　}
　　//定义具体观察者角色
　　class CDetailObsvr:public CObserver
　　{
　　public:
　　virtual UpdateOpt()
　　{
　　coutGetHeadPosition();
　　while(pos)
　　{
　　CObserver* pObsvr=(CObserver*)m_ObsvrList->GetNext(pos);
　　pObsvr->UpdateOpt();
　　}
　　}
　　public:
　　virtual void SetState(int State)
　　{
　　m_State=State;
　　NotifyObsvr();
　　}
　　CDetailSub()
　　{
　　m_ObsvrList=new CObList();
　　}
　　virtual void AddObsvr(CObserver* Observer)
　　{
　　m_ObsvrList->AddTail((CObject*)Observer);
　　}
　　virtual void DeleteObsvr()
　　{
　　m_ObsvrList->RemoveTail();
　　}
　　virtual ~CDetailSub()
　　{
　　POSITION pos=m_ObsvrList->GetHeadPosition();
　　if(pos)
　　{
　　while(pos)
　　{
　　CObserver* pObsvr=(CObserver*)m_ObsvrList->GetNex(pos);
　　delete pObsvr;
　　}
　　m_ObsvrList->RemoveAll();
　　}
　　delete m_ObsvrList;
　　}
　　}
　　};
　　int main(int argc,char* argv[])
　　{
　　CSubject* pSub=new CDetailSub();
　　pSub->AddObsvr(new CDetailObsvr());//添加观察者角色.
　　pSub->AddObsvr(new CDetailObsvr());
　　pSub->AddObsvr(new CDetailObsvr());
　　pSub->AddObsvr(new CDetailObsvr());
　　pSub->SetState(10);
　　delete pSub;
　　return 0;
　　}
　　//引入了新类CObList列表类，用来给观察者排序存储。
　　POSITITON pos为m_ObsvrList->GetHeadPositon()//头节点的位置。
　　当POS 指针不为空时，循环指向下一个位置给抽象观察者类的指针。
　　///
　　5.适配器模式
　　适配器模式是指将一个类的接口变换为客户所需的另一种接口（这里指的是虚拟函数方法）。
　　使得原来因接口不匹配而无法在一起工作的两个类能够协同工作。
　　在较老的主板上没有USB，这时使用USB,则需要一个转换器。这个转换器就为适配器。
　　适配器共涉及3个角色：目标角色，源角色，适配器角色
　　目标角色是期望实现的功能，下面是一个计算机即可以使用PCI设备又可以使用USB设备。
　　//定义目标接口
　　class CTarget
　　{
　　public:
　　virtual void UsePCI()=0;
　　virtual void UseUSB()=0;
　　};
　　//定义源接口
　　class CMainBoard
　　{
　　public:
　　virtual void UsePCI()
　　{
　　coutUsePCI();
　　PTarget->UseUSB();
　　delete pTarget;
　　return 0;
　　}
　　///
　　6.门面模式：
　　门面模式是指外部与子系统间的通信必须通过一个统一的门面对象操作进行。
　　例如：游客去旅游，需要选择景点，选择交通方式，选择住宿地点，购买门票等。如果
　　将这些交给导游，就方便多了。
　　这里的导游就是门面模式的一种体现。
　　例如：当用户需要执行关闭计算机，关闭电源，关门操作时，只需要与门面对象交涉，由门面对象执行具体的动作。
　　class CComputer
　　{
　　public:
　　void TurnOn()
　　{
　　coutGetCount()-1)
　　m_Index++;
　　}
　　virtual void Prev()
　　{
　　if(m_Index>0)
　　m_Index--;
　　}
　　virtual void Last()
　　{
　　m_Index=m_Agg->GetCount()-1;
　　}
　　virtual bool IsLast()
　　{
　　return ((m_Index==m_Agg->GetCount()-1)?true:false);
　　}
　　virtual int GetCurrent()
　　{
　　return m_Agg->m_Element[m_Index];
　　}
　　};
　　CIterator* CDetailAgg:CreateIterator()
　　{
　　return new CDetailIterator(this);
　　}
　　class CClient
　　{
　　private:
　　CAggregate* pAgg;
　　public:
　　CClient()
　　{
　　pAgg=new CDetailAgg;
　　}
　　void Operate()
　　{
　　CIterator* pIterator=pAgg->CreateIterator();
　　while(!pIterator->IsLast())
　　{
　　coutGetCurrent()Next();
　　}
　　delete pIterator;
　　}
　　virtual ~CClient()
　　{
　　delete pAgg;
　　}
　　};
　　int main(int argc,char* argv[])
　　{
　　CClient Client;
　　Client.Operate();
　　return 0;
　　}
　　//
　　8.建造模式
　　一个对象有很多属性，在这些属性没有被赋值时，对象是不能作为一个完整产品来使用的。零件具有逻辑顺序的。
　　一个整体，需要构造零件的过程，零件作为单独的对象出现，这就是采用建造模式的原因。
　　建造模式涉及到5个角色，分别为“导演者角色”，“抽象构造者角色”，“具体构造者角色”，“抽象产品角色”，“具体产品角色”
　　导演者角色负责调用具体构造者角色以创建产品对象，
　　抽象构造角色负责提供构造产品零件的统一方法；
　　具体构造者角色实现抽象构造者提供的方法，按顺序创建具体的产品。
　　抽象产品角色用于描述产品的公共属性和行为；
　　具体产品角色负责实现抽象产品中的行为。
　　#defin MAXLEN 128
　　//定义抽象产品
　　class CAnimal
　　{
　　public:
　　char* m_pMouth;
　　char* m_pFeet;
　　public:
　　virtual void Cry()=0;
　　};
　　//定义具体产品
　　class CCat:public CAnimal
　　{
　　public:
　　virtual void Cry()
　　{
　　printf("%s\n%s\n",m_pMouth,m_pFeet);
　　}
　　CCat()
　　{
　　m_pMouth=new char[MAXLEN];
　　m_pFeet=new char[MAXLEN];
　　}
　　virtual ~CCat()
　　{
　　delete[] m_pMouth;
　　delete[]m_pFeet;
　　}
　　};
　　class CDog:public CAnimal
　　{
　　public:
　　virtual void Cry()
　　{
　　printf("%s\n%s\n",m_pMouth,m_pFeet);
　　}
　　CDog()
　　{
　　m_pMouth=new char[MAXLEN];
　　m_pFeet=new char[MAXLEN];
　　}
　　virtual ~CDog()
　　{
　　delete[] m_pMouth;
　　delete[] m_pFeet;
　　}
　　};
　　//定义抽象构造者
　　class CBuilder
　　{
　　public:
　　virtual void CreateMouth()=0;
　　virtual void CreateFeet()=0;
　　virtual CAnimal* ReturnProduct()=0;
　　};
　　//定义具体构造者
　　clas CBuilderCat:public CBuilder
　　{
　　public:
　　CCat m_Cat;
　　virtual void CreateMouth()
　　{
　　m_Cat.m_pMouth="mial,miao";
　　}
　　virtual void CreateFeet()
　　{
　　m_Cat.m_pFeet="CatFeet";
　　};
　　virtual CAnimal* ReturnProduct()
　　{
　　return &m_Cat;
　　}
　　};
　　class CBuilderDog:public CBuilder
　　{
　　public:
　　CDog m_Dog;
　　vritual void CreateMouth()
　　{
　　m_Dog.m_pMouth="wan,wang";
　　}
　　virtual void CreateFeet()
　　{
　　m_Dog.m_pFeet="DogFeet";
　　}
　　virtual CAnimal* ReturnProduct()
　　{
　　return &m_Dog;
　　}
　　};
　　//定义外部客户
　　class CActor
　　{
　　public:
　　CBuiler* m_pBuilder;
　　void CreateProduct()
　　{
　　m_pBuilder=new CBuildrDog;
　　m_pBuilder->CreateMouth();
　　m_pBuilder->CreateFeet();
　　}
　　};
　　int main(int argc,char* argv[])
　　{
　　CActor actor;
　　actor.CreateProduct();
　　CAnimal* pAnimal=actor.m_pBuilder->ReturnProduct();
　　pAnimal->Cry();
　　delete actor.m_pBuilder;
　　return 0;
　　}
　　//
　　9.命令模式：
　　命令模式是一种行为模式，它将一个请求或操作封装到一个单独的对象中。将发送命令和执行命令的责任分开，委托给不同的对象执行。发送方只管发送请求。而不管请求是否被接受方收到或者接收方如何处理请求。它包含
　　客户，请求者，抽象命令，具体命令，接收者五个角色。
　　//定义抽象命令
　　class CCommand
　　{
　　public:
　　virtual void Execute()=0;
　　}
　　//定义请求者
　　class CRequestor
　　{
　　public:
　　CCommand* m_pCmd;
　　void Action()
　　{
　　m_pCmd->Execute();
　　}
　　CRequestor(CCommand* pCmd)
　　{
　　m_pCmd=pCmd;
　　}
　　};
　　//定义接收者
　　class CReceiver
　　{
　　public:
　　void Action()
　　{
　　printf("Begin doing\n");
　　}
　　};
　　//定义具体命令
　　class CDetailCmd:public CCommand
　　{
　　public :
　　CReveiver* m_pReceiver;
　　virtual void Execute()
　　{
　　m_pReceiver->Action();
　　}
　　CDetailCmd(CReceiver* pReceiver)
　　{
　　m_pReceiver=pReciver;
　　}
　　};
　　//定义客户
　　class CClient
　　{
　　public:
　　void Demo()
　　{
　　CReceiver* pReceiver=new CReceiver;
　　CCommand* pCommand=new CDetailCmd(pReceiver);
　　CRequestor* pRequestor=new CRequestor(pCommand);
　　pRequestor->Action();
　　delete pRequestor;
　　delete pCommand;
　　delete pReceiver;
　　}
　　};
　　int main(int argc,char* argv[])
　　{
　　CClinet client;
　　client.Demo();
　　return 0;
　　}
　　
　　10。状态模式，是对象的一种行为模式。它允许对象内部的状态改变，其行为也随着改变。对象
　　的行为取决于动态变化的属性。
　　状态模式主要涉及3个角色 ，分别为抽象状态，具体状态，外部状态。
　　其中，抽象状态用于定义一个统一的方法，描述外部对象中的一个特定装填所对应的行为。
　　//定义抽象状态
　　class CState
　　{
　　public: virtual void Execute()=0;
　　};
　　//定义具体状态
　　class CDetaiState:public CState
　　{
　　public:
　　virtual void Execute()
　　{
　　printf("DetailState Change\n");
　　}
　　};
　　// 定义外部对象
　　class CObj
　　{
　　public:
　　CState* m_pState;
　　void SetState(CState* pState)
　　{
　　m_pState=pState;
　　}
　　void ExecAction()
　　{
　　m_pState->Execute();
　　}
　　};
　　int main(int argc,char* argv[])
　　{
　　CObj obj;
　　CState* pState=new CDetaiLState;
　　obj.SetState(pState);
　　obj.ExecAction();
　　return 0;
　　}
　　单例模式：
　　SINGLETON SEALED// 阻止派生 READONLY,一个对象只能实例化一次。解决多线程下的它的实例化是不安全的问题。
　　//逻辑部署是指用户界面操作与业务层在同一个系统中。
　　//物理部署是指业务层脱离用户界面所在的系统，以某种文件的形式存在。
　　空间部署是指将业务层部署到服务器中。以实现业务层的远程调用。
　　比如数据库管理类，员工信息类封装后，就称为业务逻辑层。