设计模式C++学习笔记之七（AbstractFactory抽象工厂模式）

 

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

看代码：

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++还是不能真正实现。