设计模式(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