工厂模式

定义： 工厂模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，工厂方法让类把实例化推迟到子类

披萨商店实例

pizza.h

  1. //
  2. // Created by Administrator on 2022/1/5.
  3. //
  5. #ifndef PIZZA_H
  6. #define PIZZA_H
  7. #include<iostream>
  8. #include<string>
  9. #include<vector>
  11. enum PizzaType{ cheese = 0, pepperoni, clam, veggie };//Pizaa类型
  13. class Pizza{
  14. public:
  15.     Pizza(){
  16.     }
  17.     virtual ~Pizza(){
  18.     }
  19.     void prepare(){
  20.         std::cout << "准备 " << name << std::endl;
  21.         std::cout << "和面团... " << std::endl;
  22.         std::cout << "添加酱汁... " << std::endl;
  23.         std::cout << "添加配料: " <<std::endl;
  24.         for (unsigned int i = 0; i < toppings.size(); ++i)
  25.         {
  26.             std::cout <<toppings[i];
  27.         }
  28.         std::cout << std::endl;
  29.     }
  30.     void bake(){//烘烤
  31.         std::cout << "在350度的条件下烘烤25分钟" << std::endl;
  32.     }
  33.     void cut(){//切片
  34.         std::cout << "把披萨切成斜片" << std:: endl;
  35.     }
  36.     void box(){//包装
  37.         std::cout << "把披萨放入正规披萨店的包装盒" << std::endl;
  38.     }
  39.     std::string getName(){
  40.         return name;
  41.     }
  42.     void setName(std::string temp_name){
  43.         name = temp_name;
  44.     }
  45.     void setdough(std::string temp_dough){
  46.         dough = temp_dough;
  47.     }
  48.     void setSauce(std::string temp_sauce){
  49.         sauce = temp_sauce;
  50.     }
  51.     void setToppings(std::vector<std::string> temp_topp){
  52.         toppings.assign(temp_topp.begin(),temp_topp.end());
  53.     }
  54. private:
  55.     std::string name;//名称
  56.     std::string dough;//面团类型
  57.     std::string sauce;//酱料类型
  58.     std::vector<std::string> toppings;//一套作料
  59. };
  61. class NYStyleCheesePizza :public Pizza{
  62. public:
  63.     NYStyleCheesePizza(){
  64.         setName("纽约风味酱汁奶油披萨");
  65.         setdough("薄的硬壳面团");
  66.         setSauce("番茄酱");
  67.         std::vector<std::string > temp_topp;
  68.         temp_topp.push_back("磨碎的");
  69.         temp_topp.push_back("Reddiano");
  70.         temp_topp.push_back("奶油");
  71.         setToppings(temp_topp);
  72.     }
  73. };
  75. class ChicagoStyleCheesePizza :public Pizza{
  76. public:
  77.     ChicagoStyleCheesePizza(){
  78.         setName("芝加哥风味的深盘披萨");
  79.         setdough("非常薄的硬壳面团");
  80.         setSauce("梅子番茄酱");
  81.         std::vector<std::string > temp_topp;
  82.         temp_topp.push_back("切碎的");
  83.         temp_topp.push_back("Mozzarella");
  84.         temp_topp.push_back("奶油");
  85.         setToppings(temp_topp);
  86.     }
  87.     void cut(){
  88.         std::cout << "把披萨切成方形" << std::endl;//覆盖基类cut函数
  89.     }
  90. };
  92. #endif //CLION_PIZZA_H

pizzastore.h

  1. #ifndef PIZZASTORE_H_
  2. #define PIZZASTORE_H_
  3. #include "pizza.h"
  4. class PizzaStore{
  5. public:
  6.     Pizza* orderPizza(PizzaType type){
  7.         Pizza* temp_pizza;
  8.         temp_pizza = createPizza(type);
  10.         temp_pizza->prepare();
  11.         temp_pizza->bake();
  12.         temp_pizza->cut();
  13.         temp_pizza->box();
  15.         return temp_pizza;
  16.     }
  17.     virtual Pizza* createPizza(PizzaType type) = 0;
  18. };
  20. class NYPizzaStore :public PizzaStore{
  21. public:
  22.     Pizza* createPizza(PizzaType type){
  23.         Pizza *pizza = new Pizza;;
  24.         switch (type)
  25.         {
  26.             case cheese:
  27.                 pizza = new NYStyleCheesePizza();
  28.                 break;
  29.                 /*case cheese:
  30.                     pizza = new NYStyleCheesePizza();
  31.                     break;
  32.                 case cheese:
  33.                     pizza = new NYStyleCheesePizza();
  34.                     break;*/
  35.             default:
  36.                 std::cout << "There is not this type of pizze" << std::endl;
  37.         }
  38.         return pizza;
  39.     }
  40. };
  42. class ChicagoPizzaStore :public PizzaStore{
  43. public:
  44.     Pizza* createPizza(PizzaType type){
  45.         Pizza *pizza = new Pizza;
  46.         switch (type)
  47.         {
  48.             case cheese:
  49.                 pizza = new ChicagoStyleCheesePizza();
  50.                 break;
  51.                 /*case cheese:
  52.                 pizza = new NYStyleCheesePizza();
  53.                 break;
  54.                 case cheese:
  55.                 pizza = new NYStyleCheesePizza();
  56.                 break;*/
  57.             default:
  58.                 std::cout << "There is not this type of pizze" << std::endl;
  59.         }
  60.         return pizza;
  61.     }
  62. };
  63. #endif

main.cpp

  1. #include<iostream>
  2. #include "pizza.h"
  3. #include "pizzastore.h"
  5. int main()
  6. {
  7.     PizzaStore* nyStore = new NYPizzaStore();
  8.     PizzaStore* ChicagoStore = new ChicagoPizzaStore();
  9.     Pizza* pizza = nyStore->orderPizza(cheese);//小明的订单
  10.     std::cout << "make done" << std:: endl;
  11.     std::cout << "Ming ordered" << pizza->getName() << std::endl;
  12.     std::cout << std::endl;
  13.     std::cout << "----------------------------------------" << std::endl;
  14.     std::cout << std::endl;
  15.     pizza = ChicagoStore->orderPizza(cheese);//小红的订单
  16.     std::cout << "制作完毕" << std::endl;
  17.     std::cout << "这是小红点的" << pizza->getName() << std::endl;
  18. }

抽象工厂

定义： 抽象工厂提供一个用于创建相关或依赖对象的家族，而不需要明确指定具体的类。

抽象工厂利用对象组合：对象的创建被实现再工厂接口所暴露出来的方法中。

工厂方法使用继承： 把对象的创建委托给子类，子类实现工厂方法来创建对象。