C ++デザインパターンのファクトリーモデル（3）

その他 2020-10-19 18:31:35 訪問数: null

目次

  ファクトリーパターンはクリエーションパターンに属しており、シンプルファクトリーパターン、ファクトリーメソッドパターン、アブストラクトファクトリーパターンの3種類に分類できます。これら3種類のパターンは、簡単なものから難しいもの、単純なものから複雑なものまであります。これらの3つのファクトリモードについて簡単に説明しましょう

シンプルなファクトリーパターン

前書き

  シンプルファクトリーモデルは、ファクトリーモデルの最もシンプルなタイプです。さまざまな製品を製造するファクトリーです。製品の実装の詳細は外部から隠され、必要な製品タイプのみが公開されます。お客様は、必要な製品の製品タイプを工場に提供し、対応する製品を返品します。顧客は製品の基本クラスだけを気にする必要があり、どのサブクラスを取得するかを知る必要はありません。
  使用シナリオ：同じタイプの複数のタイプで使用されることがよくあります。これらのクラスは非表示にして同じインターフェイスを提供できるため、保守と変更に役立ちます。
  利点： 1。オブジェクト作成の詳細が非表示になり、製品のインスタンス化がサブクラスに実装されます。2。顧客は、使用される製品のタイプを気にする必要がなく、どの工場を知っているだけで、必要なものを提供するだけで済みます。製品の製品タイプ; 3。新製品の拡張を容易にするため; 4。依存関係の反転の原則に従います。
  短所： 1。開閉の原則に違反して、各新製品を拡張する必要があります。2。すべての製品は1つの方法でしか生産できません。製品を複数の方法または異なる方法でインスタンス化する必要がある場合、該当する。
シンプルなファクトリーパターン

コード

 enum Production_en {
     Production_0 = 0,
     Production_1,
     Production_2
 }; // Production_en

 class Production {
 public:
     virtual void product_fun() = 0;
 }; // production


 class Pro_0 : public Production {
 public:
     void product_fun();
 }; // Pro_0

 class Pro_1 : public Production {
 public:
     void product_fun();
 }; // Pro_1


 class Pro_2 : public Production {
 public:
     void product_fun() override;
 }; // Pro_2


 class SampleFactory {
 public:
     Production *create_fun(Production_en pro_type);
 }; // sample_factory



void Pro_0::product_fun() {
    std::cout << "Pro_0 production" << std::endl;
}


void Pro_1::product_fun() {
    std::cout << "Pro_1 production" << std::endl;
}


void Pro_2::product_fun() {
    std::cout << "Pro_2 production" << std::endl;
}

Production *SampleFactory::create_fun(Production_en pro_type) {
    std::shared_ptr<Production> pro = nullptr;
    switch (pro_type) {
        case Production_en::Production_0:
            pro = std::make_shared<Pro_0>();
            break;
        case Production_en::Production_1:
            pro = std::make_shared<Pro_1>();
            break;
        case Production_en::Production_2:
            pro = std::make_shared<Pro_2>();
            break;
        default:
            std::cout << "Don't support this type " << pro_type << std::endl;
            return nullptr;
    }
    return pro.get();
}

int main(){
    std::shared_ptr<SampleFactory> factory = std::make_shared<SampleFactory>();
    factory->create_fun(Production_en::Production_0)->product_fun();
    factory->create_fun(Production_en::Production_1)->product_fun();
    factory->create_fun(Production_en::Production_2)->product_fun();
    return 0;
}

ファクトリーメソッドパターン

前書き

  ファクトリーメソッドモード：1種類の製品のみを生産するファクトリーを指します。新しい製品を追加する必要がある場合は、対応するファクトリーを追加するだけで済み、開閉の原則が遵守されます。
  使用シナリオ：ファクトリメソッドモデルが開閉の原則に準拠していることを除いて、単純なファクトリモデルと一貫性があり、より柔軟になります。インスタンス化はサブクラスに延期され、サブクラスはオブジェクトをインスタンス化することを決定します。
  **利点：**シンプルなファクトリーモデルと比較して、開閉の原則にもう1つ準拠しているため、柔軟性が高くなります。
  **デメリット：**製品を追加するたびに、工場を追加する必要があります。製品が多すぎる場合、工場にも対応する数量があります。
ファクトリーメソッドパターン

コード

class ProBasic {
public:
    virtual void product_fun() = 0;
}; // ProBasic

class Pro_0 : public ProBasic {
public:
    void product_fun() override;
}; //Pro_0

class Pro_1 : public ProBasic {
public:
    void product_fun() override;
}; //Pro_1

class Pro_2 : public ProBasic {
public:
    void product_fun() override;
}; //Pro_2


class FactoryBasic {
public:
    virtual std::shared_ptr<ProBasic> create() = 0;
}; // FactoryBasic

class Factory_0 : public FactoryBasic {
public:
    std::shared_ptr<ProBasic> create() override;
}; // Factory_0

class Factory_1 : public FactoryBasic {
public:
    std::shared_ptr<ProBasic> create() override;
}; // Factory_1

class Factory_2 : public FactoryBasic {
public:
    std::shared_ptr<ProBasic> create() override;
}; // Factory_2


void Pro_0::product_fun() {
    std::cout << "Pro_0" << std::endl;
}

void Pro_1::product_fun() {
    std::cout << "Pro_1" << std::endl;
}

void Pro_2::product_fun() {
    std::cout << "Pro_2" << std::endl;
}

std::shared_ptr<ProBasic> Factory_0::create() {
    std::cout << "Factory_0 product Pro_0" << std::endl;
    return std::make_shared<Pro_0>();
}

std::shared_ptr<ProBasic> Factory_1::create() {
    std::cout << "Factory_1 product Pro_1" << std::endl;
    return std::make_shared<Pro_1>();
}

std::shared_ptr<ProBasic> Factory_2::create() {
    std::cout << "Factory_2 product Pro_2" << std::endl;
    return std::make_shared<Pro_2>();
}

int main(){
    std::shared_ptr<Factory_0> factory_0 = std::make_shared<Factory_0>();
    factory_0->create();
    std::shared_ptr<Factory_1> factory_1 = std::make_shared<Factory_1>();
    factory_1->create();
    std::shared_ptr<Factory_2> factory_3 = std::make_shared<Factory_2>();
    factory_1->create();
    return 0;
}

抽象的な工場パターン

前書き

  最初の2つのファクトリパターンと比較すると、抽象ファクトリパターンはより複雑です。上記の単純なファクトリメソッドとファクトリメソッドと同様に、製品サブクラスは同じタイプであり、共通のメソッドを持っている必要があります。これにより、製品カテゴリの拡張が制限されます。スケーラビリティを向上させるために、抽象ファクトリは同じカテゴリの製品を1つのカテゴリ（つまり、製品のグループ）に分類し、次に異なるグループの製品をファミリに結合します。現時点では、お客様は、どの工場がどのファミリの製品を製造しているかを知る必要はありません。各サブカテゴリの工場は、1つの製品ファミリのみを生産しています。指定されたサブカテゴリの工場を通じて、指定されたサブカテゴリの製品を生産します。
  利点： 1。製品の作成はカプセル化されているため、製品がどの製品であるかを知る必要はなく、工場であるかだけを知る必要があります。2.さまざまなタイプの製品をサポートできるため、モデルがより柔軟になります。3.家族でさまざまな種類の製品を使用すると非常に便利です。
   短所： 1。構造が肥大化しすぎています。より多くの製品タイプまたは製品ファミリーがある場合、拡張と保守に役立ちません。2.製品のグループを追加するたびに、すべてのファクトリクラスでメソッドを追加する必要があります。これは、オープンクローズの原則に違反します。したがって、一般的に、製品ポートフォリオと製品ファミリがあまり変更されていない状況に適用できます。
抽象的な工場パターン

コード


class ProductionBasicA{
public:
    virtual void create_a() = 0;
};

class ProductionA_1 : public ProductionBasicA{
public:
    void create_a() override;
};

class ProductionA_2 : public ProductionBasicA{
public:
    void create_a() override;
};



class ProductionBasicB{
public:
    virtual void create_b() = 0;
};

class ProductionB_1 : public ProductionBasicB{
public:
    void create_b() override;
};

class ProductionB_2 : public ProductionBasicB{
public:
    void create_b() override;
};



class FactoryBasic{
public:
    virtual std::shared_ptr<ProductionBasicA> create_production_a() = 0;
    virtual std::shared_ptr<ProductionBasicB> create_production_b() = 0;
};

class Factory1: public FactoryBasic{
public:
    std::shared_ptr<ProductionBasicA> create_production_a() override;
    std::shared_ptr<ProductionBasicB> create_production_b() override;
};

class Factory2: public FactoryBasic{
public:
    std::shared_ptr<ProductionBasicA> create_production_a() override;
    std::shared_ptr<ProductionBasicB> create_production_b() override;
};

void ProductionA_1::create_a() {
    std::cout << "ProductionA_1" << std::endl;
}

void ProductionA_2::create_a() {
    std::cout << "ProductionA_2" << std::endl;
}

void ProductionB_1::create_b() {
    std::cout << "ProductionB_1" << std::endl;
}

void ProductionB_2::create_b() {
    std::cout << "ProductionB_2" << std::endl;
}

std::shared_ptr<ProductionBasicA> Factory1::create_production_a() {
    std::cout << "Factory1 product ProductionA_1" << std::endl;
    return std::make_shared<ProductionA_1>();
}

std::shared_ptr<ProductionBasicB> Factory1::create_production_b() {
    std::cout << "Factory1 product ProductionB_1" << std::endl;
    return std::make_shared<ProductionB_1>();
}

std::shared_ptr<ProductionBasicA> Factory2::create_production_a() {
    std::cout << "Factory2 product ProductionA_2" << std::endl;
    return std::make_shared<ProductionA_2>();
}

std::shared_ptr<ProductionBasicB> Factory2::create_production_b() {
    std::cout << "Factory2 product ProductionB_2" << std::endl;
    return std::make_shared<ProductionB_2>();
}


int main(){
    std::shared_ptr<Factory1> factory_1 = std::make_shared<Factory1>();
    factory_1->create_production_a();
    factory_1->create_production_b();
    std::shared_ptr<Factory2> factory_2 = std::make_shared<Factory2>();
    factory_2->create_production_a();
    factory_2->create_production_b();
	return 0;
}

おすすめ

転載: blog.csdn.net/CFH1021/article/details/109113386
おすすめ
Face Wall Intelligence が Eurux-8x22B オープンソース大型モデルをリリース - 「科学のチャンピオン」と呼ぶにふさわしいモデル
Kaiyuan Daily | Google は、Hongmeng のオープンソース Android 携帯電話を Docker がサポート、オープンプラットフォームを閉鎖。
ランキング
Swiper を使用する際の落とし穴、どの落とし穴に陥りましたか?
データ構造基盤のリンクリスト（1）
Vue3 は Excel のアップロードと JSON データへの解析を実装し、自動ダウンロード用の JSON ファイルを生成します。
LG4721 [テンプレート]パーティションFFT
C ++のコンストラクタとデストラクタの実行順序
c3新特性多列
ライブラリのリソース
Unityエディタの拡張機能? PropertyDrawerとは何ですか? カスタムスクリプト変数のプロット?
2つのノード間のパスを見つけるのNeo4j
Linuxのnginxのを使用してCDNサーバの設定を行います
アーカイブ
もっと
2024-05-06(6)
2024-05-05(0)
2024-05-04(18)
2024-05-03(8)
2024-05-02(0)
2024-05-01(4)
2024-04-30(35)
2024-04-29(5)
2024-04-28(12)
2024-04-27(29)

コードワールド

© 2018 codetd.com