《设计模式》工厂模式

Posted 2023-03-05 joker D888

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了《设计模式》工厂模式相关的知识，希望对你有一定的参考价值。

《设计模式》工厂模式

工厂模式又分为简单工厂（Simple Factory）、工厂方法（Factory Method）和抽象工厂（Abstract Factory）都是常用的创建型设计模式，它们的主要区别如下：

简单工厂：由一个工厂类根据传入的参数来决定创建哪一种产品类的对象。简单工厂适用于对象的创建比较简单，且客户端只需要知道传入的参数即可获取相应的对象的场景。
工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法模式适用于需要一组相关对象的场景，客户端不需要知道它所使用的对象的具体类型，只需要知道创建对象的接口即可。
抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。抽象工厂模式适用于需要一组相关的对象，这些对象之间有相互依赖关系，客户端不需要知道创建对象的具体实现细节，只需要知道创建对象的接口即可。

这三种工厂模式的优点及使用场景如下：

简单工厂的优点：易于实现、客户端调用方便。适用于工厂类负责创建的对象比较少的场景。
工厂方法的优点：符合开闭原则、可扩展性强。适用于需要一组相关对象，并且需要灵活地增加、替换和删除对象的场景。
抽象工厂的优点：符合开闭原则、封装性好、可扩展性强。适用于需要创建一组相互依赖、相关或不同类型的对象的场景。

综上所述，选择哪种工厂模式取决于具体的需求场景。如果只需要创建一种对象，则可以使用简单工厂；如果需要创建一组相关的对象，并且需要灵活地增加、替换和删除对象，则可以使用工厂方法；如果需要创建一组相互依赖、相关或不同类型的对象，则可以使用抽象工厂。

简单工厂

首先，定义一个抽象产品类 Product，它是由简单工厂模式负责创建的对象：

class Product 
public:
    virtual ~Product() 
    virtual void operation() = 0;
;

接下来，定义具体产品类 ConcreteProductA 和 ConcreteProductB：

class ConcreteProductA : public Product 
public:
    void operation() 
        std::cout << "ConcreteProductA::operation()" << std::endl;
    
;

class ConcreteProductB : public Product 
public:
    void operation() 
        std::cout << "ConcreteProductB::operation()" << std::endl;
    
;

这两个类继承了抽象产品类 Product，并实现了 operation 函数。ConcreteProductA 和 ConcreteProductB 是简单工厂模式创建的具体对象。

接下来，定义一个工厂类 Factory，它负责创建具体产品的对象：

class Factory 
public:
    Product* create_product(int type) 
        switch (type) 
            case 0:
                return new ConcreteProductA();
            case 1:
                return new ConcreteProductB();
            default:
                return nullptr;
        
    
;

这个工厂类有一个 create_product 函数，根据传入的类型返回具体产品的对象。在这个示例中，我们使用 switch 语句根据类型选择创建哪种具体产品。

最后，我们可以在主函数中使用简单工厂模式创建具体产品的对象：

int main() 
    Factory factory;
    Product* productA = factory.create_product(0);
    if (productA) 
        productA->operation();
        delete productA;
    
    Product* productB = factory.create_product(1);
    if (productB) 
        productB->operation();
        delete productB;
    
    Product* productC = factory.create_product(2);
    if (!productC) 
        std::cout << "Invalid product type!" << std::endl;
    
    return 0;

在主函数中，我们先创建一个工厂对象，然后分别使用它创建 ConcreteProductA 和 ConcreteProductB 的对象，并调用它们的 operation 函数进行操作。最后，我们试图使用一个不存在的类型创建产品，这时候工厂类将返回 nullptr。

以上就是用 C++ 实现简单工厂模式的示例。

工厂方法

首先，定义一个抽象产品类 Product，它是由工厂方法模式负责创建的对象：

class Product 
public:
    virtual ~Product() 
    virtual void operation() = 0;
;

接下来，定义具体产品类 ConcreteProductA 和 ConcreteProductB：

class ConcreteProductA : public Product 
public:
    void operation() 
        std::cout << "ConcreteProductA::operation()" << std::endl;
    
;

class ConcreteProductB : public Product 
public:
    void operation() 
        std::cout << "ConcreteProductB::operation()" << std::endl;
    
;

这两个类继承了抽象产品类 Product，并实现了 operation 函数。ConcreteProductA 和 ConcreteProductB 是工厂方法模式创建的具体对象。

接下来，定义一个抽象工厂类 Factory，它声明一个工厂方法 create_product，由具体工厂类负责实现这个方法：

class Factory 
public:
    virtual ~Factory() 
    virtual Product* create_product() = 0;
;

具体工厂类继承这个抽象工厂类，并实现 create_product 方法，用于创建具体产品的对象：

class ConcreteFactoryA : public Factory 
public:
    Product* create_product() 
        return new ConcreteProductA();
    
;

class ConcreteFactoryB : public Factory 
public:
    Product* create_product() 
        return new ConcreteProductB();
    
;

这两个类继承了抽象工厂类 Factory，并实现了 create_product 方法。ConcreteFactoryA 和 ConcreteFactoryB 是工厂方法模式创建的具体工厂。

最后，我们可以在主函数中使用工厂方法模式创建具体产品的对象：

int main() 
    Factory* factoryA = new ConcreteFactoryA();
    Product* productA = factoryA->create_product();
    if (productA) 
        productA->operation();
        delete productA;
    
    delete factoryA;

    Factory* factoryB = new ConcreteFactoryB();
    Product* productB = factoryB->create_product();
    if (productB) 
        productB->operation();
        delete productB;
    
    delete factoryB;

    return 0;

在主函数中，我们先创建一个 ConcreteFactoryA 对象，然后使用它创建 ConcreteProductA 的对象，并调用它的 operation 函数进行操作。然后我们创建一个 ConcreteFactoryB 对象，使用它创建 ConcreteProductB 的对象，并调用它的 operation 函数进行操作。最后，我们删除创建的对象并销毁工厂对象。

以上就是用 C++ 实现工厂方法模式的示例。

抽象工厂

首先，定义一个抽象产品类 AbstractProductA 和 AbstractProductB，它们是由抽象工厂模式负责创建的对象：

class AbstractProductA 
public:
    virtual ~AbstractProductA() 
    virtual void operationA() = 0;
;

class AbstractProductB 
public:
    virtual ~AbstractProductB() 
    virtual void operationB() = 0;
;

接下来，定义具体产品类 ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2：

class ConcreteProductA1 : public AbstractProductA 
public:
    void operationA() 
        std::cout << "ConcreteProductA1::operationA()" << std::endl;
    
;

class ConcreteProductA2 : public AbstractProductA 
public:
    void operationA() 
        std::cout << "ConcreteProductA2::operationA()" << std::endl;
    
;

class ConcreteProductB1 : public AbstractProductB 
public:
    void operationB() 
        std::cout << "ConcreteProductB1::operationB()" << std::endl;
    
;

class ConcreteProductB2 : public AbstractProductB 
public:
    void operationB() 
        std::cout << "ConcreteProductB2::operationB()" << std::endl;
    
;

这四个类继承了抽象产品类 AbstractProductA 和 AbstractProductB，并实现了 operationA 和 operationB 函数。ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2 是抽象工厂模式创建的具体对象。

接下来，定义一个抽象工厂类 AbstractFactory，它声明一组工厂方法 createProductA 和 createProductB，由具体工厂类负责实现这些方法：

class AbstractFactory 
public:
    virtual ~AbstractFactory() 
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
;

具体工厂类继承这个抽象工厂类，并实现 createProductA 和 createProductB 方法，用于创建具体产品的对象：

class ConcreteFactory1 : public AbstractFactory 
public:
    AbstractProductA* createProductA() 
        return new ConcreteProductA1();
    

    AbstractProductB* createProductB() 
        return new ConcreteProductB1();
    
;

class ConcreteFactory2 : public AbstractFactory 
public:
    AbstractProductA* createProductA() 
        return new ConcreteProductA2();
    

    AbstractProductB* createProductB() 
        return new ConcreteProductB2();
    
;

这两个类继承了抽象工厂类 AbstractFactory，并实现了 createProductA 和 createProductB 方法。ConcreteFactory1 和 ConcreteFactory2 是抽象工厂模式创建的具体工厂。

最后，我们可以在主函数中使用抽象工厂模式创建具体产品的对象：

int main() 
    // 使用具体工厂1创建产品
    AbstractFactory* factory1 = new ConcreteFactory1();
    AbstractProductA* productA1 = factory1->createProductA();
    AbstractProductB* productB1 = factory1->createProductB();
    productA1->operationA();
    productB1->operationB();

    // 使用具体工厂2创建产品
    AbstractFactory* factory2 = new ConcreteFactory2();
    AbstractProductA* productA2 = factory2->createProductA();
    AbstractProductB* productB2 = factory2->createProductB();
    productA2->operationA();
    productB2->operationB();

    // 释放内存
    delete productA1;
    delete productB1;
    delete factory1;

    delete productA2;
    delete productB2;
    delete factory2;

    return 0;

运行结果如下：

ConcreteProductA1::operationA()
ConcreteProductB1::operationB()
ConcreteProductA2::operationA()
ConcreteProductB2::operationB()

这个示例实现了一个抽象工厂模式，其中抽象工厂类 AbstractFactory 声明了一组工厂方法，具体工厂类 ConcreteFactory1 和 ConcreteFactory2 实现了这些方法，用于创建具体产品的对象。而具体产品类 ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2 继承了抽象产品类 AbstractProductA 和 AbstractProductB，并实现了 operationA 和 operationB 函数，表示具体产品的操作。

以上就是用 C++ 实现抽象工厂模式的示例。

抽象工厂模式适用于需要一次性创建一系列相关或相互依赖的对象时，它能够提供一个简单的接口，用于创建这些对象，同时保证这些对象是相互兼容的。由于该模式要求所有具体产品都必须实现相同的接口，因此它提供了更好的灵活性和可扩展性。

以上是关于《设计模式》工厂模式的主要内容，如果未能解决你的问题，请参考以下文章

C#设计模式-抽象工厂模式

嵌入式C语言设计模式 --- 简单工厂模式

嵌入式C语言设计模式 --- 抽象工厂模式

工厂模式——简单工厂模式