C++設計模式_創建型模式

namespace _namespace2
{class Monster{public:Monster(int life, int magic, int attack) :m_life(life), m_magic(magic), m_attack(attack) {}virtual ~Monster()  // 基類 析構 虛方法{}protected:int m_life;int m_magic;int m_attack;};class M_Undead : public Monster{public:M_Undead(int life, int magic, int attack) : Monster(life,magic, attack) {cout << "亡靈類動物" << endl;}};class M_Element : public Monster{public:M_Element(int life, int magic, int attack) : Monster(life, magic, attack) {cout << "元素類動物" << endl;}};class M_Mechanic : public Monster{public:M_Mechanic(int life, int magic, int attack) : Monster(life, magic, attack) {cout << "機械類動物" << endl;}};}
void test1()
{_namespace2::Monster *m1 = new _namespace2::M_Undead(300, 100, 100);_namespace2::Monster *m2 = new _namespace2::M_Element(300, 100, 100);_namespace2::Monster *m3 = new _namespace2::M_Mechanic(300, 100, 100);/*亡靈類動物元素類動物機械類動物*/
}

????????上邊使用new? + 具體的類名來創建對象，這是一種具體類型的緊耦合關系。

1.2 簡單工廠模式

????????簡單工廠模式的實現思路：使用工廠類代替new來實現創建怪物的代碼，用戶在創建時候，與具體的類對象代碼隔離，做到了松耦合。

namespace _namespace1
{class Monster{public:Monster(int life, int magic, int attack) :m_life(life), m_magic(magic), m_attack(attack) {}virtual ~Monster()  // 基類 析構 虛方法{}protected:int m_life;int m_magic;int m_attack;};class M_Undead : public Monster{public:M_Undead(int life, int magic, int attack) : Monster(life,magic, attack) {cout << "亡靈類動物" << endl;}};class M_Element : public Monster{public:M_Element(int life, int magic, int attack) : Monster(life, magic, attack) {cout << "元素類動物" << endl;}};class M_Mechanic : public Monster{public:M_Mechanic(int life, int magic, int attack) : Monster(life, magic, attack) {cout << "機械類動物" << endl;}};// 簡單工廠模式class MonsterFactor{public:Monster * createMonster(string strmontype){Monster *ptrobj = nullptr;if (strmontype == "a"){ptrobj = new M_Undead(300, 100, 100);}else if (strmontype == "b"){ptrobj = new M_Element(300, 100, 100);}else if (strmontype == "c"){ptrobj = new M_Mechanic(300, 100, 100);}return ptrobj;}};}
void test2()
{//2  簡單工廠模式的實現思路：使用工廠類可以實現創建怪物的代碼，用戶在創建時候，與具體的類對象要實現的邏輯代碼隔離。_namespace1::MonsterFactor fac;_namespace1::Monster *m1 = fac.createMonster("a");_namespace1::Monster *m2 = fac.createMonster("b");_namespace1::Monster *m3 = fac.createMonster("c");
實例化一個工廠對象，然后通過向工廠中傳遞對應的標識來創建對象。/*亡靈類動物元素類動物機械類動物*/
}

1.3?簡單工廠模式利弊分析

????????如果想新增加一個怪物，需要修改兩個位置，首先，新增加一個新的怪物類，然后在工廠類的createMonster() 方法中再增加一個if else。這種做法不符合開閉原則。

????????開閉原則：代碼的擴展性問題：對擴展開發，對修改關閉。當增加新功能，不應該通過修改已經存在的代碼，比如在createMonster()中增加if else(), 而是應該通過擴展代碼比如增加新類，增加新成員函數來進行擴展。假如上邊要增加100個怪物類型，就要增加100個 if else()，這樣的做法不可取，如果只增加幾個，這樣方法也可以，所以應該在代碼的可讀性和可擴展性之間做出權衡。

????????上面引入簡單工廠模式的意圖：定義一個工廠類，改類的成員函數可以根據不同的參數創建并返回不同的類對象，被創建的對象所屬的類一般都具有相同的父類，比如上邊的三個怪物類都繼承自Monster類，調用者無需關系創建對象的細節。

????????簡單工廠模式：實現了創建怪物代碼語具體怪物類解耦合的效果，即創建一個類時，用戶不必知道類名字，只需調用工廠類接口，將要創建的類的類型傳入，即可創建類。

1.4 簡單工廠模式的UML圖

????????工廠和類之間是has a 關系。

二、工廠方法模式

????????工廠方法模式簡稱工廠模式或多態工廠模式；與簡單工廠模式比，靈活性更強，實現也更加復雜，一如更多的新類。每一個工廠類對應了怪物類，比如亡靈類對應的工廠為亡靈工廠類。工廠模式：修改代碼不如增加代碼好，符合開閉原則。

2.1?工廠模式和簡單工廠模式比較

????????簡單工廠模式把創建對象這件事放在一個統一的工廠中處理，每增加一個類，就要在工廠中增加對應的if else語句；而工廠模式相當于創建一個框架，從而讓子類來決定給對象如何創建。工廠方法模式往往需要創建一個與產品等級結構（層次）相同的工廠等級結構，這也新增加了新類的層次結構和數目。

2.2?工廠模式代碼實現

namespace _sp1
{// 怪物類父類class CMonster{public:CMonster(int life,int maigc,int attack):m_life(life),m_magic(maigc), m_attack(attack){}protected:int m_life;int m_magic;int m_attack;};// 亡靈類class CUnded : public CMonster{public:CUnded(int life, int maigc, int attack) :CMonster(life, maigc, attack){cout << "亡靈類來到世界" << endl;}private:};// 元素類class CEle : public CMonster{public:CEle(int life, int maigc, int attack) :CMonster(life, maigc, attack){cout << "元素類來到世界" << endl;}private:};// 機械類class CMecanical : public CMonster{public:CMecanical(int life, int maigc, int attack) :CMonster(life, maigc, attack){cout << "機械類來到世界" << endl;}};// 簡單工廠模式：創建一個工廠類，在工廠類中返回對應的 怪物類；// 工廠方法// 1 創建一個工廠基類；class CFactorMonster{public:virtual CMonster * createMonster() = 0;virtual ~CFactorMonster(){}};// 2 創建每個怪物的工廠class CFactorUnded : public CFactorMonster{public:virtual CMonster * createMonster(){CMonster *ptmp = new CUnded(200,300,400);return ptmp;}};class CFactorCEle : public CFactorMonster{public:virtual CMonster * createMonster(){CMonster *ptmp = new CEle(200, 300, 400);  // 多態return ptmp;}};// 創建一個全局方法CMonster *GlobalCreateMonster(CFactorMonster *factory){return factory->createMonster(); // 多態}
}
void test2()
{// 先 創建一個工廠父類；由于每個工廠具有固定的步驟，所以有工廠父類；_sp1::CFactorMonster *p = new _sp1::CFactorUnded();_sp1::CMonster *pp = p->createMonster();_sp1::CFactorMonster *p2 = new _sp1::CFactorCEle();_sp1::CMonster *pp2 = p2->createMonster();// 工廠模式創建了一個工廠父類，在此基礎上，又增加了每個怪物對應的工廠；// 與簡單工廠模式比，比之前的復雜，但是靈活性更強，實現了 開閉原則，付出的代價是新增加了每個怪物的工廠類；// 
}

2.3 工廠模式UML

三、抽象工廠模式

????????使用兩個示例來說明和演示什么是抽象工廠模式，場景1是戰斗場景模式，場景2是產品類

3.1?戰斗場景分類范例1?

????????上邊的三種怪物類別分別是：亡靈類，元素類和機械類。現在再將這三類怪物分為不同場景：沼澤地區，山脈地區，城鎮地區。這樣之前的三類怪物就成了9類怪物，類別如下圖所示：

上圖中有兩個概念：產品等級結構和產品族。

抽象工廠模式按照產品族來生產商品。

一個工廠子類能夠創建不止一種而是多種具有相同規則的怪物對象，也就是創建一個產品族的對象，那么就可以有效減少所創建的工廠子類數量，這就是抽象工廠模式的核心思想。

3.1.1? 抽象工程代碼實現

實現上面9種怪物：

namespace _nsp1
{// 怪物類父類class CMonster{public:CMonster(int life, int maigc, int attack) :m_life(life), m_magic(maigc), m_attack(attack){}protected:int m_life;int m_magic;int m_attack;};/// 下面分別實現這9個類別，每個怪物類都繼承自怪物父類// 城鎮亡靈類class CMonsterTownUndead : public CMonster{public:CMonsterTownUndead(int life, int magic, int attack) : CMonster(life, magic, attack){cout << "一個城鎮亡靈類型怪物來到了這個世界" << endl;}};// 城鎮元素類class CMonsterTownElement : public CMonster{public:CMonsterTownElement(int life, int magic, int attack) : CMonster(life, magic, attack){cout << "一個城鎮元素類型怪物來到了這個世界" << endl;}};// 城鎮機械類class CMonsterTownMechanic : public CMonster{public:CMonsterTownMechanic(int life, int magic, int attack) : CMonster(life, magic, attack){cout << "一個城鎮機械類型怪物來到了這個世界" << endl;}};/// 山脈類// 山脈亡靈類class CMonsterMaintainUndead : public CMonster{public:CMonsterMaintainUndead(int life, int magic, int attack) : CMonster(life, magic, attack){cout << "一個山脈亡靈類型怪物來到了這個世界" << endl;}};// 山脈元素類class CMonsterMaintainElement : public CMonster{public:CMonsterMaintainElement(int life, int magic, int attack) : CMonster(life, magic, attack){cout << "一個山脈元素類型怪物來到了這個世界" << endl;}};// 山脈機械類class CMonsterMaintainMechanic : public CMonster{public:CMonsterMaintainMechanic(int life, int magic, int attack) : CMonster(life, magic, attack){cout << "一個山脈機械類型怪物來到了這個世界" << endl;}};/// 沼澤類// 沼澤亡靈類class CMonsterMarshUndead : public CMonster{public:CMonsterMarshUndead(int life, int magic, int attack) : CMonster(life, magic, attack){cout << "一個沼澤亡靈類型怪物來到了這個世界" << endl;}};// 沼澤元素類class CMonsterMarshElement : public CMonster{public:CMonsterMarshElement(int life, int magic, int attack) : CMonster(life, magic, attack){cout << "一個沼澤元素類型怪物來到了這個世界" << endl;}};// 沼澤機械類class CMonsterMarshMechanic : public CMonster{public:CMonsterMarshMechanic(int life, int magic, int attack) : CMonster(life, magic, attack){cout << "一個沼澤機械類型怪物來到了這個世界" << endl;}};/// 創建工廠class CMonsterFactory{public:virtual CMonster *createMonsterUndead() = 0;virtual CMonster *createMonsterElement() = 0;virtual CMonster *createMonsterMechanic() = 0;virtual ~CMonsterFactory(){}};// 城鎮類工廠:一個工廠能生產一個產品族class CMonsterFactoryTown : public CMonsterFactory{virtual CMonster *createMonsterUndead(){return new CMonsterTownUndead(100, 100, 100);}virtual CMonster *createMonsterElement(){return new CMonsterTownElement(100, 100, 100);}virtual CMonster *createMonsterMechanic(){return new CMonsterTownMechanic(100, 100, 100);}};// 山脈類怪物工廠class CMonsterFactoryMaintain : public CMonsterFactory{virtual CMonster *createMonsterUndead(){return new CMonsterMaintainUndead(100, 100, 100);}virtual CMonster *createMonsterElement(){return new CMonsterMaintainElement(100, 100, 100);}virtual CMonster *createMonsterMechanic(){return new CMonsterMaintainMechanic(100, 100, 100);}};// 沼澤類怪物工廠class CMonsterFactoryMarsh : public CMonsterFactory{virtual CMonster *createMonsterUndead(){return new CMonsterMarshUndead(100, 100, 100);}virtual CMonster *createMonsterElement(){return new CMonsterMarshElement(100, 100, 100);}virtual CMonster *createMarshMechanic(){return new CMonsterMaintainMechanic(100, 100, 100);}};}int main()
{_nsp1::CMonsterFactory *pc = new _nsp1::CMonsterFactoryTown();_nsp1::CMonster *pM1 = pc->createMonsterUndead();_nsp1::CMonster *pM2 = pc->createMonsterMechanic();_nsp1::CMonster *pM3 = pc->createMonsterElement();/*一個城鎮亡靈類型怪物來到了這個世界一個城鎮機械類型怪物來到了這個世界一個城鎮元素類型怪物來到了這個世界	*/system("pause");return 0;
}

3.1.2?抽象工廠模式優缺點

1 如果增加一個新場景，比如增加一個森林場景，需要增加三個怪物，CMonsterForestUndead CMonsterForestElement? CMonsterForestMechnical等類，然后再創建森林工廠來創建這三個怪物類，這樣符合開閉原則。

2? 如果增加新怪物，比如增加龍類，不僅要增加三個繼承自CMonster的子類，還要修改Factory類，在該類中增加新的虛函數結構，比如createMonsterDragon()，同時各個子工廠中也要實現createMonsterDragon()類，這樣的修改不符合開閉原則。

3 只增加一個產品族則符合開閉原則，只需要增加新工廠子類，這是該模式的優點。如果在某個場景中，比如在游戲中，怪物種類比較固定的情況下，更適合使用抽象工廠模式。

3.1.3 抽象工廠模式UML

3.2 抽象工廠范例2

????????以生產芭比娃娃為例，芭比娃娃由三部分組成，分別是：身體，衣服，鞋子；有三個工廠都能生產芭比娃娃的這三個部分，中國工廠，日本工廠和美國工廠，產品結構圖如下：

????????現在需求，制作兩個芭比娃娃，第一個身體，衣服，鞋子全部采用中國廠商制造的部件。第二個芭比娃娃：中國生產的身體部件，日本工廠生產的衣服部件，美國產的鞋子部件。

3.2.1 代碼實現

????????類的設計思路：將身體，衣服，鞋子這三個部件實現為抽象類；實現一個抽象工廠，分別用來生產身體，衣服，鞋子這三個部件。實現這三個廠商的生產的部件。

namespace _namesp1
{// 1 三個組成部件// 身體部件 和 生產工廠class CBody{public:virtual void productName() = 0;virtual ~CBody() {}};class CBody_China : public CBody{public :virtual void productName(){cout << "中國牌身體" << endl;}};class CBody_America : public CBody{public:virtual void productName(){cout << "美國牌身體" << endl;}};class CBody_Japan : public CBody{public:virtual void productName(){cout << "日本牌身體" << endl;}};// 衣服部件 和 生產工廠class CCloth{public:virtual void productName() = 0;virtual ~CCloth() {}};class CCloth_China : public CCloth{public:virtual void productName(){cout << "中國牌衣服" << endl;}};class CCloth_America : public CCloth{public:virtual void productName(){cout << "美國牌衣服" << endl;}};class CCloth_Japan : public CCloth{public:virtual void productName(){cout << "日本牌衣服" << endl;}};// 鞋子部件 和 生產工廠class CShoes{public:virtual void productName() = 0;virtual ~CShoes() {}};class CShoes_China : public CShoes{public:virtual void productName(){cout << "中國牌鞋子" << endl;}};class CShoes_America : public CShoes{public:virtual void productName(){cout << "美國牌鞋子" << endl;}};class CShoes_Japan : public CShoes{public:virtual void productName(){cout << "日本牌鞋子" << endl;}};// 組裝芭比娃娃類class CBarbieDoll{public:CBarbieDoll(CBody *body1, CCloth *cloth1, CShoes *shoes1):body(body1),cloth(cloth1),shoes(shoes1) {}// 組成芭比娃娃void composeBar(){cout << "組成一個芭比娃娃" << endl;body->productName();cloth->productName();shoes->productName();}private:CBody *body;CCloth *cloth;CShoes *shoes;};// 抽象工廠類class CAbstractFactory{public:virtual CBody* createBody() = 0;virtual CCloth* createCloth() = 0;virtual CShoes* createShoes() = 0;virtual ~CAbstractFactory(){}};// 中國工廠class ChinaFactory : public CAbstractFactory{public:virtual CBody * createBody(){return new CBody_China;}virtual CCloth * createCloth(){return new CCloth_China;}virtual CShoes * createShoes(){return new CShoes_China;}};// 日本工廠class JapanFactory : public CAbstractFactory{public:virtual CBody * createBody(){return new CBody_Japan;}virtual CCloth * createCloth(){return new CCloth_Japan;}virtual CShoes * createShoes(){return new CShoes_Japan;}};// 美國工廠class AmericaFactory : public CAbstractFactory{public:virtual CBody * createBody(){return new CBody_America;}virtual CCloth * createCloth(){return new CCloth_America;}virtual CShoes * createShoes(){return new CShoes_America;}};
}int main()
{_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);//程序退出時檢測內存泄漏并顯示到“輸出”窗口// 生產第一個娃娃_namesp1::CAbstractFactory *pChinaFactory = new _namesp1::ChinaFactory();_namesp1::CBody *pChinaBody = pChinaFactory->createBody();_namesp1::CCloth *pChinaCloth = pChinaFactory->createCloth();_namesp1::CShoes *pChinaShoes = pChinaFactory->createShoes();// 組裝_namesp1::CBarbieDoll *pbar = new _namesp1::CBarbieDoll(pChinaBody, pChinaCloth, pChinaShoes);pbar->composeBar();// 生產第二個娃娃_namesp1::CAbstractFactory *pAmericaFactory = new _namesp1::AmericaFactory();_namesp1::CAbstractFactory *pJapanFactory = new _namesp1::JapanFactory();_namesp1::CBody *pChinaBody2 = pChinaFactory->createBody();_namesp1::CCloth *pChinaCloth2 = pJapanFactory->createCloth();_namesp1::CShoes *pChinaShoes2 = pAmericaFactory->createShoes();// 組裝_namesp1::CBarbieDoll *pbar2 = new _namesp1::CBarbieDoll(pChinaBody2, pChinaCloth2, pChinaShoes2);pbar2->composeBar();/*組成一個芭比娃娃
中國牌身體
中國牌衣服
中國牌鞋子
組成一個芭比娃娃
中國牌身體
日本牌衣服
美國牌鞋子*/system("pause");return 0;
}

抽象工廠模式定義：提供一個抽象工廠接口，此接口負責定義一個產品族；