抽象工廠,提供一個創建一系列相關或相互依賴對象的接口,而無需指定它們具體的類。對於工廠方法來說,抽象工廠可實現一系列產品的生產,抽象工廠更注重產品的組合。
看代碼:
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++還是不能真正實現。