工厂模式

工厂模式主要分三种：简单工厂模式、工厂方法模式和抽象工厂模式。

1.简单工厂模式：

1.1一个工厂类；

1.2一个抽象产品类，多个具体子类；

1.3在工厂类中添加逻辑判断，根据条件生成不同的产品；

1.4每添加一种产品，就需要在工厂类中添加相应的逻辑判断和生成代码；

#include<iostream>
using namespace std;


class product_interface
{
    public:
          virtual ~product_interface(){}

    public:
           virtual void do_something()=0;
};

class product_a
:product_interface
{
    public:
           ~product_a(){}
  
    public:
          void do_something()
         {
              cout<<"product_a created"<<endl;
         }
};

class product_b

:product_interface

{

  public:

    ~product_b(){}

  public:

     void do_something()

    {

        cout<<"product_b created"<<endl;

    }

};

class factory
{
  public:

    factory(){}

    ~factory(){}

  public:

    product_interface* create_product(string name_)

   {

      if(name_ == "product_a")

         return (new product_a);

      else if(name == "product_b")

         return (new product_b);

      else

         return NULL;

   }
}

工厂方法模式：

1.一个抽象工厂类，多个具体工厂子类；

2.一个抽象的产品类，多个具体产品子类

3.一个具体工厂类生产一个具体的产品，即工厂与产品一一对应；

4.添加一种产品，原来的工厂类不需要做任何修改，但是需要写一个新的工厂类来生成该产品；如果需要生成的产品比较多，需要创建很多工厂类；

class product
{
   public:
       virtual ~product(){}
   public:
       virtual void do_something() = 0;
};
class product_a
:public product
{
   public:
     ~product_a(){}
   public:
      void do_something()
      {
           cout<<"product_a created!"<<endl;
      }
};
class product_b
:public product
{
   public:
     ~product_b(){}
   public:
      void do_something()
      {
           cout<<"product_b created!"<<endl;
      }
};
class factory
{
   public:
       virtual ~factory(){}
   public:
       virtual product* create_product() = 0;
};
class factory_a
:public factory
{
  public:
     ~factory_a(){}
   public:
       product* create_product()
       {
            product_a* a = new product_a();
            return a;
        }
};
class factory_b
:public factory
{
    public:
        ~factory_b(){}

    public:
        product* create_product()
       {
           product_b* b = new product_b();
           return b;
       }
 
};

int main()
{
      factory_a a_factory_;
      product* pro_a = a_factory_.create_product();
      pro_a->do_something();

      factory_b b_factory_;
      product* pro_b  = b_factory_.create_product();
      pro_b->do_something();

      return 0;
}

总结：简单工厂模式和工厂模式比较起来，工厂模式添加新的产品，不需要改变现有的工厂类，只要写一个新的工厂类就可以了，但是如果产品较多，产生的工厂类会很多，所以在实际应用中，可以采取工厂方法模式和简单工厂模式结合的方式来解决实际问题。

另外，和简单工厂模式比较，工厂方法模式只是把需要创建那个产品的逻辑判断由工厂类中移到了客户应用端。

抽象工厂模式：

1.一个抽象工厂类，多个具体工厂子类；

2.多个抽象的产品类，每个抽象的产品类代表一种产品，每个抽象产品可以派生多个具体的产品类；

3.一个具体的工厂类可以创建多个产品类；

4.每个工厂可以创建一系列的不同产品（抽象类不同）,工厂和工厂直接生成的产品类的种类数和类型一一对应，但具体产品不同；

class food
{
   public:
       virtual ~food(){}
   public:
       virtual void food_do_something() = 0;
};

class meat
:public food
{
    public:
      ~meat(){}
     public:
        void food_do_something()
        {
             cout<<"meat created!"<<endl;
        }
};

class rice
:public food
{
    public:
        ~rice(){}
    public:
        void food_do_something()
        {
             cout<<"rice created!"<<endl;
        }
};

class fruit
{
     public:
         virtual ~fruit(){}
     public:
         virtual void fruit_do_something() = 0;
};

class apple
:public fruit
{
   public:
       ~apple(){}
   public:
        void fruit_do_something()
        {
             cout<<"apple created!"<<endl;
        }
};

class orange
:public fruit
{
     public:
         ~orange(){}
     public:
         void fruit_do_something()
         {
               cout<<"orange created!"<<endl;
         }
};

class human
{
   public:
      virtual ~human(){}

   public:
      virtual food*  get_food() = 0;
      virtual fruit*   get_fruit() = 0;
};

class human_a
:public human
{
   public:
       ~human_a(){}
   public:
       food* get_food()
       {
            return (new meat());
       }

       fruit*  get_fruit()
       {
           return (new apple());
        }
};

class human_b
:public human
{
   public:
     ~human_b(){}
   public:
      food* get_food()
      {
          return (new rice());
      }

      fruit* get_fruit()
     {
         return (new orange());
     }
};


int main()
{
     human* man = new human_a();
     man->get_food()->food_do_something();
     man->get_fruit()->fruit_do_something();

     human* man_1 = new human_b();     
     man_1->get_food()->food_do_something();
     man_2->get_fruit()->fruit_do_something();


      return 0;
}

总结：抽象工厂模式和工厂模式比较，抽象工厂的一个工厂类可以生成不同类型的一系列产品，而工厂方法模式一个工厂类只能生成一种产品，

因此抽象工厂适用于需要生成多个产品系的系统。