C++设计模式之AbstractFactory抽象工厂模式.txt

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

}