创建型模式のAbstractFactory抽象工厂模式
2014-03-12 01:11
363 查看
抽象工厂,提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。对于工厂方法来说,抽象工厂可实现一系列产品的生产,抽象工厂更注重产品的组合。
看代码:
IHuman,产品接口
CYellowHuman,抽象产品之一
CYellowFemaleHuman,具体产品之一
CYellowMaleHuman,具体产品之二
CWhiteHuman,抽象产品之二
CWhiteFemaleHuman,具体产品之三
CWhiteMaleHuman,具体产品之四
CBlackHuman,抽象产品之三
CBlackFemaleHuman,具体产品之五
CBlackMaleHuman,具体产品之六
IHumanFactory,抽象工厂
CStandardHumanFactory,抽象工厂基类(此类可有可无)
CFemaleHumanFactory,工厂之一
CMaleHumanFactory,工厂之二
以上类图是本例子中所用到的类的相关图,有助于理解程序实现。抽象工厂属于创建型模式。主要用于生产一系列产品,每一个工厂也可以由单件来实现。这里使用模板方式来传递参数,使代码更简洁,但Java或.Net里面的反射方式,在C++还是不能真正实现。
本文转自:~~~
看代码:
7.1.解释
main(),女娲IHuman,产品接口
CYellowHuman,抽象产品之一
CYellowFemaleHuman,具体产品之一
CYellowMaleHuman,具体产品之二
CWhiteHuman,抽象产品之二
CWhiteFemaleHuman,具体产品之三
CWhiteMaleHuman,具体产品之四
CBlackHuman,抽象产品之三
CBlackFemaleHuman,具体产品之五
CBlackMaleHuman,具体产品之六
IHumanFactory,抽象工厂
CStandardHumanFactory,抽象工厂基类(此类可有可无)
CFemaleHumanFactory,工厂之一
CMaleHumanFactory,工厂之二
//IHuman.h #pragma once class IHuman { public: IHuman(void) { } virtual ~IHuman(void) { } virtual void Laugh() = 0; virtual void Cry() = 0; virtual void Talk() = 0; virtual void Sex() = 0; };
//YellowHuman.h #pragma once #include "ihuman.h" #include <iostream> using std::cout; using std::endl; 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; };
//YellowFemaleHuman.h #pragma once #include "yellowhuman.h" #include <iostream> using std::cout; using std::endl; class CYellowFemaleHuman : public CYellowHuman { public: CYellowFemaleHuman(void) { } ~CYellowFemaleHuman(void) { } void Sex() { cout << "该黄种人的性别为女..." << endl; } }; //YellowMaleHuman.h #pragma once #include "yellowhuman.h" #include <iostream> using std::cout; using std::endl; class CYellowMaleHuman : public CYellowHuman { public: CYellowMaleHuman(void) { } ~CYellowMaleHuman(void) { } void Sex() { cout << "该黄种人的性别为男..." << endl; } };
//WhiteHuman.h #pragma once #include "ihuman.h" #include <iostream> using std::cout; using std::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; };
//WhiteFemaleHuman.h #pragma once #include "whitehuman.h" #include <iostream> using std::cout; using std::endl; class CWhiteFemaleHuman : public CWhiteHuman { public: CWhiteFemaleHuman(void) { } ~CWhiteFemaleHuman(void) { } void Sex() { cout << "该白种人的性别为女..." << endl; } }; //WhiteMaleHuman.h #pragma once #include "whitehuman.h" #include <iostream> using std::cout; using std::endl; class CWhiteMaleHuman : public CWhiteHuman { public: CWhiteMaleHuman(void) { } ~CWhiteMaleHuman(void) { } void Sex() { cout << "该白种人的性别为男..." << endl; } };
//BlackHuman.h #pragma once #include "ihuman.h" #include <iostream> using std::cout; using std::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; };
//BlackFemaleHuman.h #pragma once #include "blackhuman.h" #include <iostream> using std::cout; using std::endl; class CBlackFemaleHuman : public CBlackHuman { public: CBlackFemaleHuman(void) { } ~CBlackFemaleHuman(void) { } void Sex() { cout << "该黑种人的性别为女..." << endl; } }; //BlackMaleHuman.h #pragma once #include "blackhuman.h" #include <iostream> using std::cout; using std::endl; class CBlackMaleHuman : public CBlackHuman { public: CBlackMaleHuman(void) { } ~CBlackMaleHuman(void) { } void Sex() { cout << "该黑种人的性别为男..." << endl; } };
//IHumanFactory.h #pragma once #include "IHuman.h" class IHumanFactory { public: IHumanFactory(void) { } virtual ~IHumanFactory(void) { } virtual IHuman * CreateYellowHuman() = 0; virtual IHuman * CreateWhiteHuman() = 0; virtual IHuman * CreateBlackHuman() = 0; };
//StandardHumanFactory.h #pragma once #include "ihumanfactory.h" #include "IHuman.h" template<class T> class CStandardHumanFactory : public IHumanFactory { public: CStandardHumanFactory(void) { } ~CStandardHumanFactory(void) { } IHuman * CreateHuman() { return new T; } };
//MaleHumanFactory.h #pragma once #include "standardhumanfactory.h" #include "IHumanFactory.h" template<class T> class CMaleHumanFactory : public CStandardHumanFactory<T> { public: CMaleHumanFactory(void); ~CMaleHumanFactory(void); IHuman * CreateYellowHuman(); IHuman * CreateWhiteHuman(); IHuman * CreateBlackHuman(); }; //MaleHumanFactory.cpp #include "StdAfx.h" #include "MaleHumanFactory.h" template<class T> CMaleHumanFactory<T>::CMaleHumanFactory(void) { } template<class T> CMaleHumanFactory<T>::~CMaleHumanFactory(void) { } template<class T> IHuman * CMaleHumanFactory<T>::CreateYellowHuman() { return CreateHuman(); } template<class T> IHuman * CMaleHumanFactory<T>::CreateWhiteHuman() { return CreateHuman(); } template<class T> IHuman * CMaleHumanFactory<T>::CreateBlackHuman() { return CreateHuman(); }
//FemaleHumanFactory.h #pragma once #include "standardhumanfactory.h" template<class T> class CFemaleHumanFactory : public CStandardHumanFactory<T> { public: CFemaleHumanFactory(void) { } ~CFemaleHumanFactory(void) { } IHuman * CreateYellowHuman() { return CreateHuman(); } IHuman * CreateWhiteHuman() { return CreateHuman(); } IHuman * CreateBlackHuman() { return CreateHuman(); } };
//AbstractFactory.cpp #include "stdafx.h" #include "IHuman.h" #include "IHumanFactory.h" #include "FemaleHumanFactory.h" #include "MaleHumanFactory.h" #include "MaleHumanFactory.cpp" #include "YellowFemaleHuman.h" #include "YellowMaleHuman.h" #include "WhiteFemaleHuman.h" #include "WhiteMaleHuman.h" #include "BlackFemaleHuman.h" #include "BlackMaleHuman.h" void DoIt() { 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; } int _tmain(int argc, _TCHAR* argv[]) { DoIt(); _CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF); _CrtDumpMemoryLeaks(); return 0; }
以上类图是本例子中所用到的类的相关图,有助于理解程序实现。抽象工厂属于创建型模式。主要用于生产一系列产品,每一个工厂也可以由单件来实现。这里使用模板方式来传递参数,使代码更简洁,但Java或.Net里面的反射方式,在C++还是不能真正实现。
本文转自:~~~
相关文章推荐
- 类豌豆荚: Linux Mint实测QtADB安卓管理客户端
- poj2524_并查集基础
- Android中相对布局RelativeLayout各个属性的含义
- Java中abstract和interface的区别
- Chrome的无痕浏览实现初探
- IOS检测网络连接状态(转)
- db block gets ,consistent reads
- mac mariadb编译后无法启动
- 纯js实现微信打飞机游戏代码
- Android webapi
- Sep 15 FullCalendar日历插件说明文档
- Java NIO框架Netty教程(一) – Hello Netty
- the question of yongyou
- C#对Jason序列化匿名对象
- 转载--数论总结
- 在iis中发布自己asp.net网站
- java.lang.IllegalStateException: commit already called
- C#对象的三种序列化
- BinaryFormatter、SoapFormatter、XML3种序列化
- 扩展欧几里得