抽象工厂，提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。对于工厂方法来说，抽象工厂可实现一系列产品的生产，抽象工厂更注重产品的组合。
看代码：
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++还是不能真正实现。