抽象ファクトリパターンAbstractFactory（c ++デザインパターン）

インタビュアー：抽象的なファクトリーモデルについて話してください

シンプルファクトリーモデルから始めて、シンプルファクトリーモデルは、ファクトリーを設定することによって製品コードの繰り返し作成のほとんどをテンプレート化し、ファクトリーはパラメーターを介してさまざまな製品を作成します。
これらのパラメータは事前に定義する必要があるため、つまり、このファクトリは特定の製品しか生成できません。製品を追加または削除する場合は、ファクトリを変更する必要があります。これは、開閉の原則に違反しているため、抽象化を追加してファクトリメソッドパターンを導入します。工場、各工場は製品の作成に責任がありますが、このように多くの工場クラスがあり、システムのオーバーヘッドが増加します。
つまり、抽象ファクトリモデルがあります。抽象ファクトリモデルでは、各ファクトリが製品ファミリの作成を担当します。つまり、抽象製品と抽象ファクトリの組み合わせが導入されます。

抽象ファクトリーモデルの開閉原理の傾き

新製品ファミリーの場合、現時点で開閉の原則に準拠する新製品メーカーを追加するのと同じです
が、新しく追加された製品レベルの構造、つまり新製品を追加する場合、現時点では開閉の原則は満たされていません。

抽象ファクトリーパターンコード

/*
 * @ Description: C++ Design Patterns___Abstract Factory
 * @ version: v1.0
 * @ Author: WeissxJ
 */

#include<iostream>
class ProductA                  //抽象产品A
{
    
    
    public:
        virtual ~ProductA() {
    
    }
        virtual const char * getName()=0;
        // ...
};

class ConcreteProductAX : public ProductA   //具体产品X
{
    
    
    public:
        ~ConcreteProductAX() {
    
    }
        const char* getName(){
    
    
            return "A->X";
        }
        // ...
};

class ConcreteProductAY : public ProductA   //具体产品Y
{
    
    
    public:
        ~ConcreteProductAY() {
    
    }
        const char* getName(){
    
    
            return "A->Y";
        }
        // ...
};

class ProductB
{
    
    
    public:
        virtual ~ProductB() {
    
    }
        virtual const char * getName()=0;
        // ...
};

class ConcreteProductBX : public ProductB
{
    
    
    public:
        ~ConcreteProductBX() {
    
    }
        const char* getName(){
    
    
            return "B->X";
        }
        // ...
};

class ConcreteProductBY : public ProductB
{
    
    
    public:
        ~ConcreteProductBY() {
    
    }
        const char* getName(){
    
    
            return "B->Y";
        }
        // ...
};

class AbstractFactory
{
    
    
    public:
        virtual ~AbstractFactory() {
    
    }
        virtual ProductA* createProductA()=0;
        virtual ProductB* createProductB()=0;
};

class ConcreteFactoryX : public AbstractFactory
{
    
    
    public:
        ~ConcreteFactoryX() {
    
    }
        ProductA *createProductA(){
    
    
            return new ConcreteProductAX();
        }
        ProductB *createProductB(){
    
    
            return new ConcreteProductBX();
        }
        // ...
};

class ConcreteFactoryY : public AbstractFactory
{
    
    
    public:
        ~ConcreteFactoryY() {
    
    }
        ProductA *createProductA(){
    
    
            return new ConcreteProductAY();
        }
        ProductB *createProductB(){
    
    
            return new ConcreteProductBY();
        }
        // ...
};

int main(){
    
    
    ConcreteFactoryX *factoryX = new ConcreteFactoryX();
    ConcreteFactoryY *factoryY = new ConcreteFactoryY();

    ProductA *p1 = factoryX->createProductA();
    std::cout << "Product: " << p1->getName() << std::endl;
  
    ProductA *p2 = factoryY->createProductA();
    std::cout << "Product: " << p2->getName() << std::endl;
  
    delete p1;
    delete p2;
    
    delete factoryX;
    delete factoryY;
  
    return 0;
}

抽象ファクトリパターンAbstractFactory（c ++デザインパターン）

おすすめ