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

设计模式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 * CMaleHum
aa26
anFactory<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++还是不能真正实现。