工廠模式(統稱)

工廠模式是一種創建型模式，適用場景：安全的創建對象。

簡單工廠模式

顧名思義，工廠是用來生產東西的，而在C++里面就是用來生產對象的。
就像一家餐廳一樣，你可以按照你的方式來點餐。在工廠模式中也一樣，你可以要求工廠為你生產不同的對象。
閑話不多說，直接上代碼！

#include<iostream> #include<string> using namespace std; class Produce;//聲明產品類 class Factory;//聲明工廠類 class Factory {public:Factory(){}~Factory(){}virtual Produce* create_produce(string class_name,string name)=0;//工廠生產產品,這里的純虛函數是為了讓子工廠生產產品//返回的是一個產品類指針，這就代表了一個產品//這里的name參數是為了返回想要的產品qwq }; class Produce {public:Produce(){}~Produce(){}virtual void show_myname()=0;//這里定義的純虛函數是為了讓派生類去實現這個函數，有純虛函數的類是抽象類 }; //現在我要開始創建具體的產品了 class Produce_apple:public Produce//這是一個具體的蘋果類 {private:string name;public:Produce_apple(string new_name=""){this->name = new_name;}virtual void show_myname()//重寫父類函數 {cout<<"我的名稱是："<<name<<endl;} }; class Produce_pear:public Produce//這是一個具體的梨類 {private:string name;public:Produce_pear(string new_name=""){this->name = new_name;}virtual void show_myname()//重寫父類函數{cout<<"我的名稱是："<<name<<endl;} }; class Produce_badfruits:public Produce//這是一個具體的壞水果類 {private:string name;public:Produce_badfruits(){}virtual void show_myname()//重寫父類函數{cout<<"此產品已經過期！！"<<endl;} }; //下面開始創建具體的工廠類 class Factory_fruits:public Factory//這是個水果工廠類 {public:Factory_fruits(){}~Factory_fruits(){}virtual Produce* create_produce(string class_name,string name){if (class_name=="apple"){Produce * my_produce = new Produce_apple(name);//創建name的apple產品 return my_produce;}else if (class_name=="pear"){Produce * my_produce = new Produce_pear(name);//創建name的pear產品return my_produce;}else{Produce * my_produce = new Produce_badfruits();//創建name的pear產品return my_produce;}} }; //初期的搭建工作已經完成，總結一下，我們搭建了兩個抽象類：工廠類，產品類；//產品派生類：蘋果類，梨類，壞水果類//工廠派生類：水果工廠類。//現在我們要用這些東西了 int main() {Factory * my_factory_fruits = new Factory_fruits();//創建一個抽象工廠對象"升級"為水果工廠//這里的"升級"是我的理解 ,事實上是類型轉換 Produce * my_produce_apple = my_factory_fruits->create_produce("apple","紅富士");//創建抽象產品對象，"升級"為水果工廠加工出來的apple,紅富士 Produce * my_produce_pear = my_factory_fruits->create_produce("pear","冰糖雪梨");//創建抽象產品對象，"升級"為水果工廠加工出來的pear,冰糖雪梨Produce * my_produce_banana = my_factory_fruits->create_produce("banana","大香蕉");//創建抽象產品對象，"升級"為水果工廠加工出來的banana,大香蕉，但是工廠不能生產banana,所以只能生產badfruit壞水果 my_produce_apple->show_myname();//產品顯示自己的名稱 my_produce_pear->show_myname();//產品顯示自己的名稱my_produce_banana->show_myname();//產品顯示自己的名稱//下面是銷毀內存delete my_factory_fruits;my_factory_fruits = NULL;delete my_produce_apple;my_produce_apple = NULL;delete my_produce_pear;my_produce_pear = NULL;delete my_produce_banana;my_produce_banana = NULL;return 0; }

這是一個簡單工廠模式，在實際的程序開發中，可以將那些具體的產品類編譯成DLL，這樣可以做到熱更新！

工廠模式

顧名思義工廠模式，并沒有那么簡單qwq.他不是像簡單工廠那樣一個水果工廠可以生產各種水果，而是一種工廠生產一種水果。就比如蘋果工廠生產蘋果，梨子工廠生產梨子。這樣分開的好處是什么呢？？？
我看了很多博客，他們都提到了 開放-封閉原則，我用我自己的話來說，就是如果你想增加新西瓜的產品的話。用簡單工廠模式需要增加一個西瓜類，然后在水果工廠里面增加分支。用工廠模式的話需要增加一個西瓜類和一個西瓜類工廠。。。
但是我們的老師經常教導我們，不要改源碼！！！如果用的是簡單工廠模式就必須改源碼中的條件分支，這會被老師罵死的qwq。所以用工廠模式就不用改源碼，只用增加代碼即可，媽媽再也不用擔心我被罵了。
上代碼！！

#include<iostream> #include<string> using namespace std; class Produce;//聲明產品類 class Factory;//聲明工廠類 class Factory {public:Factory(){}~Factory(){}virtual Produce* create_produce(string name)=0;//工廠生產產品,這里的純虛函數是為了讓子工廠生產產品//返回的是一個產品類指針，這就代表了一個產品//這里的name參數是為了返回想要的產品qwq }; class Produce {public:Produce(){}~Produce(){}virtual void show_myname()=0;//這里定義的純虛函數是為了讓派生類去實現這個函數，有純虛函數的類是抽象類 }; //現在我要開始創建具體的產品了 class Produce_apple:public Produce//這是一個具體的蘋果類 {private:string name;public:Produce_apple(string new_name=""){this->name = new_name;}virtual void show_myname()//重寫父類函數 {cout<<"我的名稱是："<<name<<endl;} }; class Produce_pear:public Produce//這是一個具體的梨類 {private:string name;public:Produce_pear(string new_name=""){this->name = new_name;}virtual void show_myname()//重寫父類函數{cout<<"我的名稱是："<<name<<endl;} }; class Produce_banana:public Produce//這是一個具體的壞水果類 {private:string name;public:Produce_banana(string new_name=""){this->name = new_name;}virtual void show_myname()//重寫父類函數{cout<<"我的名稱是："<<name<<endl;} }; //下面開始創建具體的工廠類 class Factory_apple:public Factory//這是個水果工廠類 {public:Factory_apple(){}~Factory_apple(){}virtual Produce* create_produce(string name){Produce * my_produce = new Produce_apple(name);//創建name的apple產品 return my_produce;} }; class Factory_pear:public Factory//這是個水果工廠類 {public:Factory_pear(){}~Factory_pear(){}virtual Produce* create_produce(string name){Produce * my_produce = new Produce_pear(name);//創建name的pear產品 return my_produce;} }; class Factory_banana:public Factory//這是個水果工廠類 {public:Factory_banana(){}~Factory_banana(){}virtual Produce* create_produce(string name){Produce * my_produce = new Produce_banana(name);//創建name的badfruits產品 return my_produce;} }; //初期的搭建工作已經完成，總結一下，我們搭建了兩個抽象類：工廠類，產品類；//產品派生類：蘋果類，梨類，壞水果類//工廠派生類：蘋果工廠類。梨類工廠類。壞水果工廠類 //現在我們要用這些東西了 int main() {Factory * my_factory_apple = new Factory_apple();//創建一個抽象工廠對象"升級"為蘋果工廠//這里的"升級"是我的理解 ,事實上是類型轉換Factory * my_factory_pear = new Factory_pear();//創建一個抽象工廠對象"升級"為梨子工廠Factory * my_factory_banana = new Factory_banana();//創建一個抽象工廠對象"升級"為香蕉工廠Produce * my_produce_apple = my_factory_apple->create_produce("紅富士");//創建抽象產品對象，"升級"為蘋果工廠加工出來的apple,紅富士 Produce * my_produce_pear = my_factory_pear->create_produce("冰糖雪梨");//創建抽象產品對象，"升級"為梨子工廠加工出來的pear,冰糖雪梨Produce * my_produce_banana = my_factory_banana->create_produce("大香蕉");//創建抽象產品對象，"升級"為香蕉工廠加工出來的banana my_produce_apple->show_myname();//產品顯示自己的名稱 my_produce_pear->show_myname();//產品顯示自己的名稱my_produce_banana->show_myname();//產品顯示自己的名稱//下面是銷毀內存delete my_factory_apple;my_factory_apple = NULL;delete my_factory_pear;my_factory_pear = NULL;delete my_factory_banana;my_factory_banana = NULL;delete my_produce_apple;my_produce_apple = NULL;delete my_produce_pear;my_produce_pear = NULL;delete my_produce_banana;my_produce_banana = NULL;return 0; }

抽象工廠模式

顧名思義這個模式比普通的工廠模式抽象一點。
按照我個人的理解，簡單工廠模式，工廠模式，抽象模式主要的差別就在與工廠的分類不同。
簡單工廠模式：一個產品一個工廠，十個產品一個工廠。總結：工廠可以生產所有產品
工廠模式：一個產品一個工廠，十個產品十個工廠。總結：工廠只能生產一個產品
抽象工廠模式：N個產品M個工廠。總結：工廠可以靈活的生產商品。

還是按剛才的例子，我現在要賣蘋果，蘋果汁，梨子，梨子汁。
簡單工廠模式就是1個工廠賣四個產品。
工廠模式就是創建四個工廠賣四個產品。
抽象工廠模式就不一樣：我可以創建兩個工廠。一個專門賣蘋果類的，一個專門賣梨子類的，除了這樣的分類，還可以進行其他的分類，十分的靈活！

閑話不多說，上代碼！！

#include<iostream> #include<string> using namespace std; class Produce_fruits;//聲明水果產品類 class Produce_fruits_juice;//聲明水果汁產品類 class Factory;//聲明工廠類 class Factory {public:Factory(){}~Factory(){}virtual Produce_fruits* create_produce(string name)=0;//工廠生產產品,這里的純虛函數是為了讓子工廠生產產品//返回的是一個產品類指針，這就代表了一個產品//這里的name參數是為了返回想要的產品qwqvirtual Produce_fruits_juice* create_produce_juice(string name)=0;//工廠生產產品,這里的純虛函數是為了讓子工廠生產產品//返回的是一個產品類指針，這就代表了一個產品//這里的name參數是為了返回想要的產品qwq }; class Produce_fruits {public:Produce_fruits(){}~Produce_fruits(){}virtual void show_myname()=0;//這里定義的純虛函數是為了讓派生類去實現這個函數，有純虛函數的類是抽象類 }; class Produce_fruits_juice {public:Produce_fruits_juice(){}~Produce_fruits_juice(){}virtual void show_myname()=0;//這里定義的純虛函數是為了讓派生類去實現這個函數，有純虛函數的類是抽象類 }; //現在我要開始創建具體的產品了 class Produce_apple:public Produce_fruits//這是一個具體的蘋果類 {private:string name;public:Produce_apple(string new_name=""){this->name = new_name;}virtual void show_myname()//重寫父類函數 {cout<<"我的名稱是："<<name<<"（水果）"<<endl;} }; class Produce_pear:public Produce_fruits//這是一個具體的梨類 {private:string name;public:Produce_pear(string new_name=""){this->name = new_name;}virtual void show_myname()//重寫父類函數{cout<<"我的名稱是："<<name<<"（水果）"<<endl;} }; class Produce_apple_juice:public Produce_fruits_juice//這是一個具體的蘋果類 {private:string name;public:Produce_apple_juice(string new_name=""){this->name = new_name;}virtual void show_myname()//重寫父類函數 {cout<<"我的名稱是："<<name<<"（果汁）"<<endl;} }; class Produce_pear_juice:public Produce_fruits_juice//這是一個具體的梨類 {private:string name;public:Produce_pear_juice(string new_name=""){this->name = new_name;}virtual void show_myname()//重寫父類函數{cout<<"我的名稱是："<<name<<"（果汁）"<<endl;} }; //下面開始創建具體的工廠類 class Factory_apple:public Factory//這是個蘋果工廠類 {public:Factory_apple(){}~Factory_apple(){}virtual Produce_fruits* create_produce(string name){Produce_fruits * my_produce = new Produce_apple(name);//創建name的蘋果產品 return my_produce;}virtual Produce_fruits_juice* create_produce_juice(string name){Produce_fruits_juice * my_produce = new Produce_apple_juice(name);//創建name的蘋果汁產品 return my_produce;} }; class Factory_pear:public Factory//這是個梨工廠類 {public:Factory_pear(){}~Factory_pear(){}virtual Produce_fruits* create_produce(string name){Produce_fruits * my_produce = new Produce_pear(name);//創建name的梨子產品 return my_produce;}virtual Produce_fruits_juice* create_produce_juice(string name){Produce_fruits_juice * my_produce = new Produce_pear_juice(name);//創建name的梨子汁產品 return my_produce;} }; //初期的搭建工作已經完成，總結一下，我們搭建了兩個抽象類：工廠類，水果產品類，果汁產品類；//產品派生類：蘋果類，梨類，蘋果汁類，梨汁類，//工廠派生類：蘋果工廠類，梨子工廠類。//現在我們要用這些東西了 int main() {Factory * my_factory_apple = new Factory_apple();//創建一個抽象工廠對象"升級"為蘋果工廠//這里的"升級"是我的理解 ,事實上是類型轉換Factory * my_factory_pear = new Factory_pear();//創建一個抽象工廠對象"升級"為梨子工廠//這里的"升級"是我的理解 ,事實上是類型轉換 Produce_fruits * my_produce_apple = my_factory_apple->create_produce("紅富士");//創建抽象產品對象，"升級"為蘋果工廠加工出來的紅富士 Produce_fruits * my_produce_pear = my_factory_pear->create_produce("鴨梨");//創建抽象產品對象，"升級"為梨子工廠加工出來的鴨梨Produce_fruits_juice * my_produce_apple_juice = my_factory_apple->create_produce_juice("紅蘋果汁");//創建抽象產品對象，"升級"為蘋果工廠加工出來的紅蘋果汁Produce_fruits_juice * my_produce_pear_juice = my_factory_pear->create_produce_juice("冰糖雪梨果汁");//創建抽象產品對象，"升級"為梨子工廠加工出來的冰糖雪梨果汁 my_produce_apple->show_myname();//產品顯示自己的名稱 my_produce_pear->show_myname();//產品顯示自己的名稱my_produce_apple_juice->show_myname();//產品顯示自己的名稱my_produce_pear_juice->show_myname();//產品顯示自己的名稱//下面是銷毀內存 delete my_factory_apple;my_factory_apple = NULL;delete my_factory_pear;my_factory_pear = NULL;delete my_produce_apple;my_produce_apple = NULL;delete my_produce_pear;my_produce_pear = NULL;delete my_produce_apple_juice;my_produce_apple_juice = NULL;delete my_produce_pear_juice;my_produce_pear_juice = NULL;return 0; }

總結:

##### 特點： 簡單工廠模式：一個工廠N個產品 工廠模式：N個工廠N個產品 抽象工廠模式：N個工廠M個產品 ##### 缺點（相對）： 簡單工廠模式：違背了開放封閉原則（改動源碼），產品多了會比較雜 工廠模式：產品多了會很雜，代碼量稍大，產品多了會比較雜 抽象工廠模式：違背了開放封閉原則（改動源碼），代碼量大，產品多了會比較非常雜 ##### 優點（相對）： 簡單工廠模式：代碼量小，方便添加新的產品 工廠模式：不違背了開放封閉原則（不改動源碼），方便添加新的產品 抽象工廠模式：模式靈活，調用方便

在實際開發中可以混用,人的思維是靈活的，代碼才是靈活的，功能才是靈活的，不同的工具靈活使用才能發揮出最大的功能

總結

以上是生活随笔為你收集整理的工厂模式C++实现（三种工厂模式附详细注释）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。