【C++设计模式】创建型模式—抽象工厂模式

目录

抽象工厂模式

---

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它允许你创建一系列相关或相互依赖的对象，而无需指定它们具体的类。抽象工厂模式通过提供一个接口来创建一系列相关或依赖对象的家族，而不需要指定具体类。

抽象工厂模式通常包含以下角色：

1. 抽象工厂（Abstract Factory）：

   • 声明了一组创建抽象产品的方法，每个方法对应一种具体产品类的创建方法。

2. 具体工厂（Concrete Factory）：

   • 实现了抽象工厂接口，负责具体产品的创建。

3. 抽象产品（Abstract Product）：

   • 声明了产品的接口，是工厂方法创建的对象的父类。

4. 具体产品（Concrete Product）：

   • 实现了抽象产品接口的具体类。

#include <iostream>
#include <memory>

// 抽象产品A
class AbstractProductA {
public:
    virtual void operationA() = 0;
    virtual ~AbstractProductA() {}
};

// 具体产品类 A1
class ConcreteProductA1 : public AbstractProductA {
public:
    void operationA() override {
        std::cout << "ConcreteProductA1" << std::endl;
    }
};

// 具体产品类 A2
class ConcreteProductA2 : public AbstractProductA {
public:
    void operationA() override {
        std::cout << "ConcreteProductA2" << std::endl;
    }
};

// 抽象产品B
class AbstractProductB {
public:
    virtual void operationB() = 0;
    virtual ~AbstractProductB() {}
};

// 具体产品类 B1
class ConcreteProductB1 : public AbstractProductB {
public:
    void operationB() override {
        std::cout << "ConcreteProductB1" << std::endl;
    }
};

// 具体产品类 B2
class ConcreteProductB2 : public AbstractProductB {
public:
    void operationB() override {
        std::cout << "ConcreteProductB2" << std::endl;
    }
};

// 抽象类工厂
class AbstractFactory {
public:
    virtual std::unique_ptr<AbstractProductA>createProductA() = 0;
    virtual std::unique_ptr<AbstractProductB>createProductB() = 0;
    virtual ~AbstractFactory() {}
};

// 具体工厂类1，负责创建产品族1
class ConcreteFactor1 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ConcreteProductA1>();
    }

    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ConcreteProductB1>();
    }
};

// 具体工厂类2，负责创建产品族2
class ConcreteFactor2 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ConcreteProductA2>();
    }

    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ConcreteProductB2>();
    }
};

int main()
{
    // 使用具体工厂类1创建产品族1的实例
    std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactor1>();
    std::unique_ptr<AbstractProductA> productA1 = factory1->createProductA();
    std::unique_ptr<AbstractProductB> productB1 = factory1->createProductB();

    productA1->operationA();
    productB1->operationB();

    // 使用具体工厂类2创建产品族2的实例
    std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactor2>();
    std::unique_ptr<AbstractProductA> productA2 = factory2->createProductA();
    std::unique_ptr<AbstractProductB> productB2 = factory2->createProductB();

    productA2->operationA();
    productB2->operationB();

    return 0;
}

1. 抽象产品类 (AbstractProductA, AbstractProductB):

   • 定义了产品族中每个产品的接口。

2. 具体产品类 (ConcreteProductA1, ConcreteProductA2, ConcreteProductB1, ConcreteProductB2):

   • 实现了抽象产品类定义的接口，提供具体的产品功能。

3. 抽象工厂类 (AbstractFactory):

   • 声明了创建产品族的方法接口。

4. 具体工厂类 (ConcreteFactory1, ConcreteFactory2):

   • 实现了抽象工厂类中的方法，每个具体工厂类负责创建一组相关的产品族。

5. 主函数 (main):

   • 创建具体工厂类的实例，并使用其方法创建对应产品族的具体产品实例。
   • 每个产品族的产品实例通过其接口方法进行操作。

在抽象工厂模式中，每个具体工厂类不仅负责创建产品，而且确保创建的产品是属于同一产品族的，从而保证产品之间的兼容性和一致性。