设计模式(c++)笔记之二（AbstractFactory抽象工厂模式）

一、简介：

  

    抽象工厂，提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。对于工厂方法来说，抽象工厂可实现一系列产品的生产，抽象工厂更注重产品的组合。

AbstractFactory 模式典型的结构图为: 

图 2-1:AbstractFactory Pattern 结构图

AbstractFactory 模式关键就是将这一组对象的创建封装到一个用于创建对象的类

(ConcreteFactory)中,维护这样一个创建类总比维护n多相关对象的创建过程要简单的多。 

二、实例

    上一篇博文讲到女娲造人,人是造出来了,世界时热闹了,可是低头一看,都是清一色的类型,缺少关爱、仇恨、喜怒哀乐等情绪,人类的生命太平淡了,女娲一想,猛然一拍脑袋,Shit!忘记给人类定义性别了,那怎么办?抹掉重来,然后就把人类重新洗牌,准备重新开始制造人类。

由于先前的工作已经花费了很大的精力做为铺垫,也不想从头开始了,那先说人类(Product 产品类)怎么改吧,好,有了,给每个人类都加一个性别,然后再重新制造,这个问题解决了,那八卦炉怎么办?只有一个呀,要么生产出全都是男性,要不都是女性,那不行呀,有了,把已经有了一条生产线——八卦炉(工厂模式中的 Concrete Factory)拆开,于是女娲就使用了“八卦拷贝术”,把原先的八卦炉一个变两个,并且略加修改,就成了女性八卦炉(只生产女性,一个具体工厂的实现类)和男性八卦炉(只生产男性,又一个具体工厂的实现类),这个过程的类图如下: 

注释：

    main()，女娲

    IHuman，产品接口

    CYellowHuman，抽象产品之一

    CYellowFemaleHuman，具体产品之一

    CYellowMaleHuman，具体产品之二

    CWhiteHuman，抽象产品之二

    CWhiteFemaleHuman，具体产品之三

    CWhiteMaleHuman，具体产品之四

    CBlackHuman，抽象产品之三

    CBlackFemaleHuman，具体产品之五

    CBlackMaleHuman，具体产品之六

    IHumanFactory，抽象工厂

    CStandardHumanFactory，抽象工厂基类（此类可有可无）

    CFemaleHumanFactory，工厂之一

    CMaleHumanFactory，工厂之二

我的工程目录：

      

三、实现代码

产品接口类IHuman

IHuman.h

#ifndef __Factory__IHuman__#define __Factory__IHuman__class IHuman {        public:    IHuman(void)    {    }    virtual ~IHuman(void)    {    }    virtual void Laugh() = 0;    virtual void Cry() = 0;    virtual void Talk() = 0;    virtual void Sex() = 0;};#endif /* defined(__Factory__IHuman__) */

黑种人抽象类BlackHuman

BlackHuman.h

#ifndef __Factory__BlackHuman__#define __Factory__BlackHuman__#include <iostream>#include "IHuman.h"class CBlackHuman :public IHuman{public:    CBlackHuman(void);    ~CBlackHuman(void);    void Laugh();    void Cry();    void Talk();    virtual void Sex() = 0;};#endif /* defined(__Factory__BlackHuman__) */

BlackHuman.cpp

#include "BlackHuman.h"#include <iostream>using std::cout;using std::endl;CBlackHuman::CBlackHuman(void){}CBlackHuman::~CBlackHuman(void){}void CBlackHuman::Cry(){    cout << "黑人会哭" << endl;}void CBlackHuman::Laugh(){    cout << "黑人会笑" << endl;}void CBlackHuman::Talk(){    cout << "黑人可以说话，一般人听不懂" << endl;}

黑种人（男）具体实现类BlackMaleHuman

BlackMaleHuman.h

#ifndef __AbstractFactory__BlackMaleHuman__#define __AbstractFactory__BlackMaleHuman__#include <iostream>#include "BlackHuman.h"using std::cout;using std::endl;class CBlackMaleHuman :public CBlackHuman{public:    CBlackMaleHuman(void)    {    }    ~CBlackMaleHuman(void)    {    }    void Sex()    {        cout << "该黑种人的性别为男..." << endl;    }};#endif /* defined(__AbstractFactory__BlackMaleHuman__) */

黑种人（女）具体实现类BlackFemaleHuman

BlackFemaleHuman.h

#ifndef __AbstractFactory__BlackFemaleHuman__#define __AbstractFactory__BlackFemaleHuman__#include <iostream>#include "BlackHuman.h"using std::cout;using std::endl;class CBlackFemaleHuman :public CBlackHuman{public:    CBlackFemaleHuman(void)    {    }    ~CBlackFemaleHuman(void)    {    }    void Sex()    {        cout << "该黑种人的性别为女..." << endl;    }};#endif /* defined(__AbstractFactory__BlackFemaleHuman__) */

白种人抽象类WhiteHuman

WhiteHuman.h

#ifndef __Factory__WhiteHuman__#define __Factory__WhiteHuman__#include "IHuman.h"class CWhiteHuman :public IHuman{public:    CWhiteHuman(void);    ~CWhiteHuman(void);    void Laugh();    void Cry();    void Talk();    virtual void Sex() = 0;};#endif /* defined(__Factory__WhiteHuman__) */

WhiteHuman.cpp

#include "WhiteHuman.h"#include <iostream>using std::cout;using std::endl;CWhiteHuman::CWhiteHuman(void){}CWhiteHuman::~CWhiteHuman(void){}void CWhiteHuman::Cry(){    cout << "白色人种会哭" << endl;}void CWhiteHuman::Laugh(){    cout << "白色人种会大笑，侵略的笑声" << endl;}void CWhiteHuman::Talk(){    cout << "白色人种会说话，一般都是单字节" << endl;}

白种人（男）具体实现类WhiteMaleHuman

WhiteMaleHuman.h

#ifndef __AbstractFactory__WhiteMaleHuman__#define __AbstractFactory__WhiteMaleHuman__#include <iostream>#include "WhiteHuman.h"using std::cout;using std::endl;class CWhiteMaleHuman :public CWhiteHuman{public:    CWhiteMaleHuman(void)    {    }    ~CWhiteMaleHuman(void)    {    }    void Sex()    {        cout << "该白种人的性别为男..." << endl;    }};#endif /* defined(__AbstractFactory__WhiteMaleHuman__) */

白种人（男）具体实现类WhiteFemaleHuman

WhiteFemaleHuman.h

#ifndef __AbstractFactory__WhiteFemaleHuman__#define __AbstractFactory__WhiteFemaleHuman__#include <iostream>#include "WhiteHuman.h"#include <iostream>using std::cout;using std::endl;class CWhiteFemaleHuman : public CWhiteHuman{public:    CWhiteFemaleHuman(void)    {    }    ~CWhiteFemaleHuman(void)    {    }    void Sex()    {        cout << "该白种人的性别为女..." << endl;    }};#endif /* defined(__AbstractFactory__WhiteFemaleHuman__) */

黄种人抽象类YellowHuman

YellowHuman.h

#ifndef __Factory__YellowHuman__#define __Factory__YellowHuman__#include "IHuman.h"class CYellowHuman :public IHuman{public:    CYellowHuman(void);    ~CYellowHuman(void);    void Laugh();    void Cry();    void Talk();    virtual void Sex() = 0;};#endif /* defined(__Factory__YellowHuman__) */

YellowHuman.cpp

#include "YellowHuman.h"#include <iostream>using std::cout;using std::endl;CYellowHuman::CYellowHuman(void){}CYellowHuman::~CYellowHuman(void){}void CYellowHuman::Cry(){    cout << "黄色人种会哭" << endl;}void CYellowHuman::Laugh(){    cout << "黄色人种会大笑，幸福呀！" << endl;}void CYellowHuman::Talk(){    cout << "黄色人种会说话，一般说的都是双字节" << endl;}

黄种人（男）具体实现类YellowMaleHuman

YellowMaleHuman.h

#ifndef __AbstractFactory__YellowMaleHuman__#define __AbstractFactory__YellowMaleHuman__#include "yellowhuman.h"#include <iostream>using std::cout;using std::endl;class CYellowMaleHuman :public CYellowHuman{public:    CYellowMaleHuman(void)    {    }    ~CYellowMaleHuman(void)    {    }    void Sex()    {        cout << "该黄种人的性别为男..." << endl;    }};#endif /* defined(__AbstractFactory__YellowMaleHuman__) */

黄种人（女）具体实现类YellowFemaleHuman

YellowFemaleHuman.h

#ifndef __AbstractFactory__YellowFemaleHuman__#define __AbstractFactory__YellowFemaleHuman__#include <iostream>#include "YellowHuman.h"using std::cout;using std::endl;class CYellowFemaleHuman :public CYellowHuman{public:    CYellowFemaleHuman(void)    {    }    ~CYellowFemaleHuman(void)    {    }    void Sex()    {        cout << "该黄种人的性别为女..." << endl;    }};#endif /* defined(__AbstractFactory__YellowFemaleHuman__) */

抽象工厂类IHumanFactory

IHumanFactory.h

#ifndef __AbstractFactory__IHumanFactory__#define __AbstractFactory__IHumanFactory__#include <iostream>#include "IHuman.h"class IHumanFactory{public:    IHumanFactory(void){}    virtual ~IHumanFactory(void){}    virtual IHuman *CreateYellowHuman() = 0;    virtual IHuman *CreateWhiteHuman() = 0;    virtual IHuman *CreateBlackHuman() = 0;};#endif /* defined(__AbstractFactory__IHumanFactory__) */

抽象工厂基类（此类可有可无）CStandardHumanFactory

StandardHumanFactory.h

#ifndef __AbstractFactory__StandardHumanFactory__#define __AbstractFactory__StandardHumanFactory__#include <iostream>#include "IHumanFactory.h"#include "IHuman.h"template<class T>class CStandardHumanFactory:public IHumanFactory{public:    CStandardHumanFactory(void)    {    }    ~CStandardHumanFactory(void)    {    }    IHuman * CreateHuman()    {        return new T;    }};#endif /* defined(__AbstractFactory__StandardHumanFactory__) */

创造(男)工厂类MaleHumanFactory

MaleHumanFactory.h

#ifndef __AbstractFactory__MaleHumanFactory__#define __AbstractFactory__MaleHumanFactory__#include <iostream>#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();};#endif /* defined(__AbstractFactory__MaleHumanFactory__) */

MaleHumanFactory.cpp

#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();    return CStandardHumanFactory<T>::CreateHuman();}template<class T>IHuman * CMaleHumanFactory<T>::CreateWhiteHuman(){    //return CreateHuman();    return CStandardHumanFactory<T>::CreateHuman();}template<class T>IHuman * CMaleHumanFactory<T>::CreateBlackHuman(){   // return CreateHuman();    return CStandardHumanFactory<T>::CreateHuman();}

创造(女)工厂类MaleHumanFactory

#ifndef __AbstractFactory__FemaleHumanFactory__#define __AbstractFactory__FemaleHumanFactory__#include <iostream>#include "standardhumanfactory.h"#include "IHuman.h"template<class T>class CFemaleHumanFactory:public CStandardHumanFactory<T> {        public:     CFemaleHumanFactory(void)     {     }     ~CFemaleHumanFactory(void)     {     }     IHuman * CreateYellowHuman()     {         return CStandardHumanFactory<T>::CreateHuman();        //return CreateHuman();     }     IHuman * CreateWhiteHuman()     {         return CStandardHumanFactory<T>::CreateHuman();        // return CreateHuman();     }     IHuman * CreateBlackHuman()     {         return CStandardHumanFactory<T>::CreateHuman();         //return CreateHuman();     }};#endif /* defined(__AbstractFactory__FemaleHumanFactory__) */

主类main.cpp

#include <stdio.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 main(int argc, const char * argv[]){    DoIt();     // insert code here...    printf("Hello, World!\n");    return 0;}

结果如下：

参考文献：《设计模式之禅》，《GoF_23种设计模式解析》

参考博客：http://www.cnblogs.com/wanggary/archive/2011/04/13/2015288.html