【C++设计模式】工厂模式

最近打算总结一下设计模式（希望可以坚持写完...)。

设计模式大体上可以分为三种：

1）创建型（5种）

具体包括：工厂方法（包括简单工厂），抽象工厂，单例，建造者，原型

2）结构型模式（7种）

具体包括：适配器，桥接，组合，装饰器，代理，外观，享元

3）行为型模式（11种）

具体包括：策略模式，模版方法，命令，职责链，状态，观察者，中介者，迭代器，访问者，备忘录，解释器

创建型模式的技巧主要应用于创建对象的方式上。

结构性模式的技巧主要在于对不同类之间的组合以实现代码复用。

行为型模式的技巧在于不同类之间的相互作用及相互影响。

创建型模式

1）简单工厂模式

简单工厂一般只包含一个工厂，以及产品抽象类及其子类。

优点：实现了对象的创建与使用的分离。

缺点： 每增加一个产品都要修改原来的代码，且需要不断增加新的逻辑。

enum fruits{
  APPLE,
  GRAPE
}

//果汁抽象类
class Juice{
public:
        virtual void show() = 0;
}

//果汁具体类，苹果汁
class AppleJuice : public Juice{
public:
      void show(){
      cout<<"AppleJuice"<<endl;
    }
}
//果汁具体类，葡萄汁
class GrapeJuice : public Juice{
public:
      void show(){
      cout<<"GrapeJuice"<<endl;
    }
}

//工厂类
class Factory{
public:
      Juice* getJuice(int type){
      switch (type){
        case APPLE:
          return new AppleJuice();
        case GRAPE:
          return new GrapeJuice();
        default:
          break;
      }
      return NULL;
    }
}


//主函数的使用
int main()
{
  Factory* fac = new Factory(); 
  Juice* applejuice1 = fac.getJuice(APPLE);
  Juice* grapejuice1 = fac.getJuice(GRAPE);
  
  delete fac;
  delete applejuice1;
  delete grapejuice1;
  
}

2）工厂方法

工厂方法在于为每一种产品建立一个工厂。一个工厂只生产一种产品。

因此需要同时包含产品抽象类和工厂抽象类。

优点：增加新的产品不需要修改原来的代码。

//果汁抽象类
class Juice{
public:
        virtual void show() = 0;
}

//果汁具体类，苹果汁
class AppleJuice : public Juice{
public:
      void show(){
      cout<<"AppleJuice"<<endl;
    }
}
//果汁具体类，葡萄汁
class GrapeJuice : public Juice{
public:
      void show(){
      cout<<"GrapeJuice"<<endl;
    }
}


//工厂抽象类
class Factory{
public:
  virtual Juice* createJuice() = 0
}

//苹果汁工厂类
class AppleJuiceFactory{
public:
      Juice* createJuice(){
      return new AppleJuice();
    }
}

class GrapeJuiceFactor{
public:
      Juice* createJuice(){
      return new GrapeJuice();
    }
}

int main(){
    
      Factory* fac1 = new AppleJuiceFactory();
      Factory* fac2 = new GrapeJuiceFactory();
  
      Juice* applejuice1 = fac1.createJuice();
      Juice* grapeJuice1 = fac2.createJuice();
      
      //delete...

}

3）抽象工厂模式

让一个工厂拥有好几条产品线。

优点：方便扩展新的产品系列

缺点：增加新的产品时，需要修改所有工厂

//果汁抽象类
class Juice{
public:
        virtual void show() = 0;
}

class Jam{
public:
      virtual void show() = 0;
}
//果汁具体类，苹果汁
class AppleJuice : public Juice{
public:
      void show(){
      cout<<"AppleJuice"<<endl;
    }
}
//果汁具体类，葡萄汁
class GrapeJuice : public Juice{
public:
      void show(){
      cout<<"GrapeJuice"<<endl;
    }
}

//果酱具体类，苹果酱
class AppleJam: public Jam{
public:
      void show(){
      cout<<"AppleJam"<<endl;
    }
}

//果酱具体类，葡萄酱
class GrapeJam: public Jam{
public:
      void show(){
      cout<<"GrapeJam"<<endl;
    }
}

//工厂抽象类
class Factory{
public:
      virtual Juice* createJuice() = 0;
       virtual Jam* createJam() = 0;
}

//工厂具体类，苹果工厂
class AppleFactory{
public:
      Juice* createJuice(){
          return new AppleJuice();
    }
      Jam* createJame(){
          return new AppleJam();
    }
}

//工厂具体类，葡萄工厂
class GrapeFactory{
public:
      Juice* createJuice(){
          return new GrapeJuice();
    }
      Jam* createJame(){
          return new GrapeJam();
    }
}

int main(){
　　　　
      Factory* fac1 = new AppleFactory();
      Juice* applejuice1 = fac1.createJuice();
      Jam* applejam1 = fac1.createJam();
  
      Factory* fac2 = new GrapeFactory();
      Juice* grapeJuice2 = fac2.createJuice();
      Jam* grapejam2 = fac2.createJam()''

  
}