C++抽象工厂

头文件：

#ifndef CABSTRACTFACTORY_H
#define CABSTRACTFACTORY_H
#include<iostream>
#include<string>
using namespace std;


namespace CabstractFactory {

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

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;
};

//具体产品之一，继承自YellowHuman

class CYellowFemaleHuman :
        public CYellowHuman
{
public:
    CYellowFemaleHuman(void)
    {
    }
    ~CYellowFemaleHuman(void)
    {
    }
    void Sex()
    {
        cout << "该黄种人的性别为女..." << endl;
    }
};

//具体产品，继承自YellowHuman
class CYellowMaleHuman :
        public CYellowHuman
{
public:
    CYellowMaleHuman(void)
    {
    }
    ~CYellowMaleHuman(void)
    {
    }
    void Sex()
    {
        cout << "该黄种人的性别为男..." << endl;
    }
};

//抽象产品之二WhiteHuman

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;
};
//具体产品，继承自CWhiteHuman

class CWhiteFemaleHuman :
        public CWhiteHuman
{
public:
    CWhiteFemaleHuman(void)
    {
    }
    ~CWhiteFemaleHuman(void)
    {
    }
    void Sex()
    {
        cout << "该白种人的性别为女..." << endl;
    }
};
//具体产品，继承自CWhiteHuman
class CWhiteMaleHuman :
        public CWhiteHuman
{
public:
    CWhiteMaleHuman(void)
    {
    }
    ~CWhiteMaleHuman(void)
    {
    }
    void Sex()
    {
        cout << "该白种人的性别为男..." << 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;
};
//具体产品，继承自CBlackHuman
class CBlackFemaleHuman :
        public CBlackHuman
{
public:
    CBlackFemaleHuman(void)
    {
    }
    ~CBlackFemaleHuman(void)
    {
    }
    void Sex()
    {
        cout << "该黑种人的性别为女..." << endl;
    }
};
//具体产品，继承自CBlackHuman
//BlackMaleHuman.h


class CBlackMaleHuman :
        public CBlackHuman
{
public:
    CBlackMaleHuman(void)
    {
    }
    ~CBlackMaleHuman(void)
    {
    }
    void Sex()
    {
        cout << "该黑种人的性别为男..." << endl;
    }
};


//抽象工厂
class IHumanFactory
{
public:
    IHumanFactory(void)
    {
    }
    virtual ~IHumanFactory(void)
    {
    }
    virtual IHuman * CreateYellowHuman() = 0;
    virtual IHuman * CreateWhiteHuman() = 0;
    virtual IHuman * CreateBlackHuman() = 0;
};
//抽象工厂基类（此类可有可无）
template<class T>
class CStandardHumanFactory :
        public IHumanFactory
{
public:
    CStandardHumanFactory(void)
    {
    }
    ~CStandardHumanFactory(void)
    {
    }
    IHuman * CreateHuman();
};
template<class T>
IHuman * CStandardHumanFactory<T>::CreateHuman()
{
    return new T;
}

//男人工厂

template<class T>
class CMaleHumanFactory :
        public CStandardHumanFactory<T>
{
public:
    CMaleHumanFactory(void);
    ~CMaleHumanFactory(void);
    IHuman * CreateYellowHuman();
    IHuman * CreateWhiteHuman();
    IHuman * CreateBlackHuman();
};



template<class T>
CMaleHumanFactory<T>::CMaleHumanFactory(void)
{
}
template<class T>
CMaleHumanFactory<T>::~CMaleHumanFactory(void)
{
}
template<class T>
IHuman * CMaleHumanFactory<T>::CreateYellowHuman()
{
    return this->CreateHuman();
}
template<class T>
IHuman * CMaleHumanFactory<T>::CreateWhiteHuman()
{
    return this->CreateHuman();
}
template<class T>
IHuman * CMaleHumanFactory<T>::CreateBlackHuman()
{
    return this->CreateHuman();
}


//女人工厂

template<class T>
class CFemaleHumanFactory :
        public CStandardHumanFactory<T>
{
public:
    CFemaleHumanFactory(void)
    {
    }
    ~CFemaleHumanFactory(void)
    {
    }
    IHuman * CreateYellowHuman()
    {
        return this->CreateHuman();
    }
    IHuman * CreateWhiteHuman()
    {
        return this->CreateHuman();
    }
    IHuman * CreateBlackHuman()
    {
        return this->CreateHuman();
    }
};


}


#endif // CABSTRACTFACTORY_H

源文件：

#include "cabstractfactory.h"

using namespace CabstractFactory;

void CabstractfactoryTestt()
{
    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;

}