設計模式(c++)筆記之二（AbstractFactory抽象工廠模式）
阿新 • • 發佈：2019-02-04
一、簡介：
抽象工廠，提供一個建立一系列相關或相互依賴物件的介面，而無需指定它們具體的類。對於工廠方法來說，抽象工廠可實現一系列產品的生產，抽象工廠更注重產品的組合。
AbstractFactory 模式典型的結構圖為:
圖 2-1:AbstractFactory Pattern 結構圖
AbstractFactory 模式關鍵就是將這一組物件的建立封裝到一個用於建立物件的類
(ConcreteFactory)中,維護這樣一個建立類總比維護n多相關物件的建立過程要簡單的多。
二、例項
上一篇博文講到女媧造人,人是造出來了,世界時熱鬧了,可是低頭一看,都是清一色的型別,缺少關愛、仇恨、喜怒哀樂等情緒,人類的生命太平淡了,女媧一想,猛然一拍腦袋,Shit!忘記給人類定義性別了,那怎麼辦?抹掉重來,然後就把人類重新洗牌,準備重新開始製造人類。
由於先前的工作已經花費了很大的精力做為鋪墊,也不想從頭開始了,那先說人類(Product 產品類)怎麼改吧,好,有了,給每個人類都加一個性別,然後再重新制造,這個問題解決了,那八卦爐怎麼辦?只有一個呀,要麼生產出全都是男性,要不都是女性,那不行呀,有了,把已經有了一條生產線——八卦爐(工廠模式中的 Concrete Factory)拆開,於是女媧就使用了“八卦拷貝術”,把原先的八卦爐一個變兩個,並且略加修改,就成了女性八卦爐(只生產女性,一個具體工廠的實現類)和男性八卦爐(只生產男性,又一個具體工廠的實現類),這個過程的類圖如下:
註釋：
main()，女媧
IHuman，產品介面
CYellowHuman，抽象產品之一
CYellowFemaleHuman，具體產品之一
CYellowMaleHuman，具體產品之二
CWhiteHuman，抽象產品之二
CWhiteFemaleHuman，具體產品之三
CWhiteMaleHuman，具體產品之四
CBlackHuman，抽象產品之三
CBlackFemaleHuman，具體產品之五
CBlackMaleHuman，具體產品之六
IHumanFactory，抽象工廠
CStandardHumanFactory，抽象工廠基類（此類可有可無）
CFemaleHumanFactory，工廠之一
CMaleHumanFactory，工廠之二
我的工程目錄：
三、實現程式碼
產品介面類IHuman
IHuman.h
#ifndef __Factory__IHuman__
#define __Factory__IHuman__
class IHuman {
public:
IHuman(void)
{
}
virtual ~IHuman(void)
{
}
virtual void Laugh() = 0;
virtual void Cry() = 0;
virtual void Talk() = 0;
virtual void Sex() = 0;
};
#endif /* defined(__Factory__IHuman__) */黑種人抽象類BlackHuman
BlackHuman.h
#ifndef __Factory__BlackHuman__
#define __Factory__BlackHuman__
#include <iostream>
#include "IHuman.h"
class CBlackHuman :public IHuman
{
public:
CBlackHuman(void);
~CBlackHuman(void);
void Laugh();
void Cry();
void Talk();
virtual void Sex() = 0;
};
#endif /* defined(__Factory__BlackHuman__) */#include "BlackHuman.h"
#include <iostream>
using std::cout;
using std::endl;
CBlackHuman::CBlackHuman(void)
{
}
CBlackHuman::~CBlackHuman(void)
{
}
void CBlackHuman::Cry()
{
cout << "黑人會哭" << endl;
}
void CBlackHuman::Laugh()
{
cout << "黑人會笑" << endl;
}
void CBlackHuman::Talk()
{
cout << "黑人可以說話，一般人聽不懂" << endl;
}黑種人（男）具體實現類BlackMaleHuman
BlackMaleHuman.h
#ifndef __AbstractFactory__BlackMaleHuman__
#define __AbstractFactory__BlackMaleHuman__
#include <iostream>
#include "BlackHuman.h"
using std::cout;
using std::endl;
class CBlackMaleHuman :
public CBlackHuman
{
public:
CBlackMaleHuman(void)
{
}
~CBlackMaleHuman(void)
{
}
void Sex()
{
cout << "該黑種人的性別為男..." << endl;
}
};
#endif /* defined(__AbstractFactory__BlackMaleHuman__) */黑種人（女）具體實現類BlackFemaleHuman
BlackFemaleHuman.h
#ifndef __AbstractFactory__BlackFemaleHuman__
#define __AbstractFactory__BlackFemaleHuman__
#include <iostream>
#include "BlackHuman.h"
using std::cout;
using std::endl;
class CBlackFemaleHuman :public CBlackHuman
{
public:
CBlackFemaleHuman(void)
{
}
~CBlackFemaleHuman(void)
{
}
void Sex()
{
cout << "該黑種人的性別為女..." << endl;
}
};
#endif /* defined(__AbstractFactory__BlackFemaleHuman__) */
白種人抽象類WhiteHuman
WhiteHuman.h
#ifndef __Factory__WhiteHuman__
#define __Factory__WhiteHuman__
#include "IHuman.h"
class CWhiteHuman :
public IHuman
{
public:
CWhiteHuman(void);
~CWhiteHuman(void);
void Laugh();
void Cry();
void Talk();
virtual void Sex() = 0;
};
#endif /* defined(__Factory__WhiteHuman__) */
#include "WhiteHuman.h"
#include <iostream>
using std::cout;
using std::endl;
CWhiteHuman::CWhiteHuman(void)
{
}
CWhiteHuman::~CWhiteHuman(void)
{
}
void CWhiteHuman::Cry()
{
cout << "白色人種會哭" << endl;
}
void CWhiteHuman::Laugh()
{
cout << "白色人種會大笑，侵略的笑聲" << endl;
}
void CWhiteHuman::Talk()
{
cout << "白色人種會說話，一般都是單位元組" << endl;
}白種人（男）具體實現類WhiteMaleHuman
WhiteMaleHuman.h
#ifndef __AbstractFactory__WhiteMaleHuman__
#define __AbstractFactory__WhiteMaleHuman__
#include <iostream>
#include "WhiteHuman.h"
using std::cout;
using std::endl;
class CWhiteMaleHuman :
public CWhiteHuman
{
public:
CWhiteMaleHuman(void)
{
}
~CWhiteMaleHuman(void)
{
}
void Sex()
{
cout << "該白種人的性別為男..." << endl;
}
};
#endif /* defined(__AbstractFactory__WhiteMaleHuman__) */白種人（男）具體實現類WhiteFemaleHuman
WhiteFemaleHuman.h
#ifndef __AbstractFactory__WhiteFemaleHuman__
#define __AbstractFactory__WhiteFemaleHuman__
#include <iostream>
#include "WhiteHuman.h"
#include <iostream>
using std::cout;
using std::endl;
class CWhiteFemaleHuman : public CWhiteHuman
{
public:
CWhiteFemaleHuman(void)
{
}
~CWhiteFemaleHuman(void)
{
}
void Sex()
{
cout << "該白種人的性別為女..." << endl;
}
};
#endif /* defined(__AbstractFactory__WhiteFemaleHuman__) */黃種人抽象類YellowHuman
YellowHuman.h
#ifndef __Factory__YellowHuman__
#define __Factory__YellowHuman__
#include "IHuman.h"
class CYellowHuman :public IHuman
{
public:
CYellowHuman(void);
~CYellowHuman(void);
void Laugh();
void Cry();
void Talk();
virtual void Sex() = 0;
};
#endif /* defined(__Factory__YellowHuman__) */
#include "YellowHuman.h"
#include <iostream>
using std::cout;
using std::endl;
CYellowHuman::CYellowHuman(void)
{
}
CYellowHuman::~CYellowHuman(void)
{
}
void CYellowHuman::Cry()
{
cout << "黃色人種會哭" << endl;
}
void CYellowHuman::Laugh()
{
cout << "黃色人種會大笑，幸福呀！" << endl;
}
void CYellowHuman::Talk()
{
cout << "黃色人種會說話，一般說的都是雙位元組" << endl;
}
黃種人（男）具體實現類YellowMaleHuman
YellowMaleHuman.h
#ifndef __AbstractFactory__YellowMaleHuman__
#define __AbstractFactory__YellowMaleHuman__
#include "yellowhuman.h"
#include <iostream>
using std::cout;
using std::endl;
class CYellowMaleHuman :
public CYellowHuman
{
public:
CYellowMaleHuman(void)
{
}
~CYellowMaleHuman(void)
{
}
void Sex()
{
cout << "該黃種人的性別為男..." << endl;
}
};
#endif /* defined(__AbstractFactory__YellowMaleHuman__) */
黃種人（女）具體實現類YellowFemaleHuman
YellowFemaleHuman.h
#ifndef __AbstractFactory__YellowFemaleHuman__
#define __AbstractFactory__YellowFemaleHuman__
#include <iostream>
#include "YellowHuman.h"
using std::cout;
using std::endl;
class CYellowFemaleHuman :
public CYellowHuman
{
public:
CYellowFemaleHuman(void)
{
}
~CYellowFemaleHuman(void)
{
}
void Sex()
{
cout << "該黃種人的性別為女..." << endl;
}
};
#endif /* defined(__AbstractFactory__YellowFemaleHuman__) */抽象工廠類IHumanFactory
IHumanFactory.h
#ifndef __AbstractFactory__IHumanFactory__
#define __AbstractFactory__IHumanFactory__
#include <iostream>
#include "IHuman.h"
class IHumanFactory
{
public:
IHumanFactory(void){}
virtual ~IHumanFactory(void){}
virtual IHuman *CreateYellowHuman() = 0;
virtual IHuman *CreateWhiteHuman() = 0;
virtual IHuman *CreateBlackHuman() = 0;
};
#endif /* defined(__AbstractFactory__IHumanFactory__) */
抽象工廠基類（此類可有可無）CStandardHumanFactory
StandardHumanFactory.h
#ifndef __AbstractFactory__StandardHumanFactory__
#define __AbstractFactory__StandardHumanFactory__
#include <iostream>
#include "IHumanFactory.h"
#include "IHuman.h"
template<class T>
class CStandardHumanFactory:public IHumanFactory
{
public:
CStandardHumanFactory(void)
{
}
~CStandardHumanFactory(void)
{
}
IHuman * CreateHuman()
{
return new T;
}
};
#endif /* defined(__AbstractFactory__StandardHumanFactory__) */
創造(男)工廠類MaleHumanFactory
MaleHumanFactory.h
#ifndef __AbstractFactory__MaleHumanFactory__
#define __AbstractFactory__MaleHumanFactory__
#include <iostream>
#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();
};
#endif /* defined(__AbstractFactory__MaleHumanFactory__) */
#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();
return CStandardHumanFactory<T>::CreateHuman();
}
template<class T>
IHuman * CMaleHumanFactory<T>::CreateWhiteHuman()
{
//return CreateHuman();
return CStandardHumanFactory<T>::CreateHuman();
}
template<class T>
IHuman * CMaleHumanFactory<T>::CreateBlackHuman()
{
// return CreateHuman();
return CStandardHumanFactory<T>::CreateHuman();
}創造(女)工廠類MaleHumanFactory
#ifndef __AbstractFactory__FemaleHumanFactory__
#define __AbstractFactory__FemaleHumanFactory__
#include <iostream>
#include "standardhumanfactory.h"
#include "IHuman.h"
template<class T>
class CFemaleHumanFactory:public CStandardHumanFactory<T>
{
public:
CFemaleHumanFactory(void)
{
}
~CFemaleHumanFactory(void)
{
}
IHuman * CreateYellowHuman()
{
return CStandardHumanFactory<T>::CreateHuman();
//return CreateHuman();
}
IHuman * CreateWhiteHuman()
{
return CStandardHumanFactory<T>::CreateHuman();
// return CreateHuman();
}
IHuman * CreateBlackHuman()
{
return CStandardHumanFactory<T>::CreateHuman();
//return CreateHuman();
}
};
#endif /* defined(__AbstractFactory__FemaleHumanFactory__) */主類main.cpp
#include <stdio.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 main(int argc, const char * argv[])
{
DoIt();
// insert code here...
printf("Hello, World!\n");
return 0;
}
結果如下：
參考文獻：《設計模式之禪》，《GoF_23種設計模式解析》
參考部落格：http://www.cnblogs.com/wanggary/archive/2011/04/13/2015288.html