[C ++設計パターン工場パターン]

我々は（...仕上げに接着するように望んで）最近のデザインパターンを要約する予定。

デザインパターンは、3つのタイプに分けることができます。

1）種類（5種類）を作成

含む：（簡単な工場を含む）ファクトリメソッド、抽象工場、単一の実施形態、ビルダー、プロトタイプ

2）構造モデル（7種）

具体的に含む：アダプタ、ブリッジ、組み合わせ、デコレータ、薬剤、外観、フライを

モデルの3）タイプ（11種）

含む：Strategyパターン、テンプレートの方法、順序、責任、状態、観測者、仲介者、イテレータ、訪問者、メモ、通訳の連鎖

モードの種類を作成するためのヒントは、主にオブジェクトを作成する方法で使用されています。

主に異なるクラス間の組み合わせパターンの構造技術は、コードの再利用を実現します。

その相互作用と異なるクラス間の相互影響のヒント行動パターン。

スキーマを作成します。

1）単純なファクトリパターン

シンプルな工場は、一般的に一つだけの工場だけでなく、製品抽象クラスとそのサブクラスが含まれています。

長所：オブジェクトの作成と利用の分離を達成します。

短所：各追加の製品は、元のコードを変更し、新しいロジックを追加していく必要がある必要があります。

列挙型の果物{
  林檎、
  グレープ
}

// ジュース抽象クラスの
クラスジュース{
 パブリック：
         仮想 無効ショー（）= 0 ;
}

// ジュース具象クラス、リンゴジュース
クラスリンゴジュース：公共ジュース{
 パブリック：
       無効ショー（）{
      裁判所未満 << " リンゴジュース" << てendl;
    }
}
// ジュースコンクリートクラス、グレープジュースの
クラス GrapeJuice：公共ジュース{
 パブリック：
       無効ショー（）{
      裁判所未満 << " GrapeJuice " << てendl;
    }
}

// ファクトリクラスの
クラスファクトリの{
 パブリック：
      ジュース * getJuice（INTのタイプ）{
       スイッチ（タイプ）{
         ケースAPPLE：
           戻り 新しいリンゴジュース（）。
        ケースGRAPE：
           リターン 新しいGrapeJuice（）;
        デフォルト：
           休憩;
      }
      リターンNULL;
    }
}


// 使用メイン関数
int型のmain（）
{
  工場 * FAC = 新工場（）;
  ジュース * applejuice1 = fac.getJuice（APPLE）。
  ジュース * grapejuice1 = fac.getJuice（GRAPE）。
  
  削除FAC;
  削除applejuice1;
  削除grapejuice1;
  
}

2）ファクトリメソッド

ファクトリメソッドは、各製品の工場を建設することです。1つの製品だけを生産する工場。

そこで我々は、製品に抽象クラスと抽象ファクトリクラスを含める必要があります。

長所：元のコードを変更せずに新製品を追加します。

// ジュース抽象クラスの
クラスジュース{
 パブリック：
         仮想 無効ショー（）= 0 ;
}

// ジュース具象クラス、リンゴジュース
クラスリンゴジュース：公共ジュース{
 パブリック：
       無効ショー（）{
      裁判所未満 << " リンゴジュース" << て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()''

  
}