工厂模式 C++实现

工厂模式

简单工厂模式

​ 所谓简单工厂模式，是一种实例化对象的方式，只要输入需要实例化对象的名字，就可以通过工厂对象的相应工厂函数来制造你需要的对象。

​ 简单工厂模式的核心是，对于一个父类的多个继承子类，工厂对象的工厂函数根据用户输入，自动new出一个子类对象并返回其父类的指针，这样利用父类的指针执行父类的虚函数，就可以动态绑定子类的重写函数，从而实现多态。

​ 对于一个只拥有加减乘除运算的简单计算器，我们设计一个Operation的父类，并构造加减乘除四个类继承父类重写运算函数GetResult。然后定义工厂类中的工厂函数，其根据用户的输入new出相应的对象实例并返回其父类的指针。

  #include<iostream>
  ​
  using namespace std;
  class Operation 
  {
  private:
      double _numberA = 0;
      double _numberB = 0;
  public:
      double getA()
      {
          return  _numberA; 
      }
      double getB()
      {
          return  _numberB;
      }
  ​
      void setA(double x)
      {
          _numberA = x;
      }
      void setB(double x)
      {
          _numberB = x;
      }
      virtual double Getresult()
      {
          double result = 0;
          return result;
      }
  ​
  };
  class Add :public Operation {
      double Getresult()
      {
          double result = 0;
          result = getA() + getB();
          return result;
      }
  };
  class Sub :public Operation {
      double Getresult()
      {
          double result = 0;
          result = getA() - getB();
          return result;
      }
  };
  /*-------------------简单工厂模型--------------------*/
   class OperationFactory
   {
  public:
       static Operation* createoperate(char operate)
      {
          Operation* oper=NULL;
          switch (operate)
          {
          case '+': oper = new Add(); break;
          case '-': oper = new Sub(); break;
          }
          return oper;
      }
  };
  /*-------------------简单工厂模型--------------------*/
  ​
  int main()
  {
      double A, B;
      cin >> A >> B;
      Operation *oper;
      oper = OperationFactory::createoperate('+');
      oper->setA(A);
      oper->setB(B);
      cout << oper->Getresult()<< endl;
      return 0;
  }

工厂方法模式

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关类，对于客户端来说，去除了与具体产品的依赖。

工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。想要增加的功能，本来是改工厂类的，现在是修改客户端。

优点：增加新的功能时，只需要增加次功能的实现类和相应的工厂类就可以，这样整个工厂和产品体系都没有修改和变化，只是扩展的变化，这就完全符合了开放-封闭原则的精神。

  
  #include<iostream>
  ​
  using namespace std;
  class Operation
  {
  private:
      double _numberA = 0;
      double _numberB = 0;
  public:
      double getA()
      {
          return  _numberA;
      }
      double getB()
      {
          return  _numberB;
      }
  ​
      void setA(double x)
      {
          _numberA = x;
      }
      void setB(double x)
      {
          _numberB = x;
      }
      virtual double Getresult()
      {
          double result = 0;
          return result;
      }
  ​
  };
  class Add :public Operation {
      double Getresult()
      {
          double result = 0;
          result = getA() + getB();
          return result;
      }
  };
  class Sub :public Operation {
      double Getresult()
      {
          double result = 0;
          result = getA() - getB();
          return result;
      }
  };
  /*----------------工厂方法模式-------------------------*/
  __interface IFactory
  {
      Operation* CreateOperation();
  };
  ​
  ​
  class  AddFactory :public IFactory
  {
  public:
      Operation* CreateOperation()
      {
          Operation* oper = NULL;
          oper = new Add();
          return oper;
      }
  };
  class  SubFactory :public IFactory
  {
  public:
      Operation* CreateOperation()
      {
          Operation* oper = NULL;
          oper = new Sub();
          return oper;
      }
  };
  /*----------------工厂方法模式-------------------------*/
  int main()
  {
      double A, B;
      cin >> A >> B;
      IFactory* operFactory=new SubFactory;
      Operation *oper = operFactory->CreateOperation();
      oper->setA(A);
      oper->setB(B);
      cout << oper->Getresult() << endl;
      return 0;
  }

抽象工厂模式

​ 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

工厂方法模式与抽象工厂模式区别