当前位置：首页 > article >正文

抽象工厂模式的C++实现示例

article 2025/3/15 10:10:07

核心思想

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种方式，可以创建一系列相关或依赖的对象，而无需指定它们的具体类。抽象工厂模式的核心思想是：
抽象工厂接口：定义一个接口，用于创建一系列相关或依赖的对象。
具体工厂实现：实现抽象工厂接口，创建具体的对象。
抽象产品接口：定义一类产品的接口。
具体产品实现：实现抽象产品接口，创建具体的产品。

解决的问题

产品族创建：当需要创建一系列相关或依赖的对象时，抽象工厂模式可以确保这些对象是兼容的。
客户端与具体类解耦：客户端代码只需要知道抽象工厂和抽象产品接口，而不需要知道具体的实现类，从而降低了耦合度。
易于扩展：当需要增加新的产品族时，只需要增加新的工厂类和产品类，而不需要修改现有代码。

使用场景

产品族创建：当需要创建一系列相关或依赖的对象时，例如不同操作系统的界面组件（按钮、文本框等）。
系统独立性：当需要确保系统与具体类解耦，以便于扩展和维护。
配置文件驱动：当需要通过配置文件或其他方式动态选择产品族时。

优点

产品族一致性：确保创建的对象是兼容的。
客户端与具体类解耦：客户端代码只需要知道抽象接口，而不需要知道具体实现类。
易于扩展：增加新的产品族时，只需要增加新的工厂类和产品类，而不需要修改现有代码。

缺点

复杂性增加：增加了系统的复杂性，需要更多的类和接口。
不易于支持新种类的产品：如果需要增加新的种类的产品，需要修改抽象工厂接口及其所有实现类。

示例代码

#include <iostream>
#include <memory>

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

// 具体产品A1
class ProductA1 : public AbstractProductA {
public:
    void use() override {
        std::cout << "Using ProductA1" << std::endl;
    }
};

// 具体产品A2
class ProductA2 : public AbstractProductA {
public:
    void use() override {
        std::cout << "Using ProductA2" << std::endl;
    }
};

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

// 具体产品B1
class ProductB1 : public AbstractProductB {
public:
    void use() override {
        std::cout << "Using ProductB1" << std::endl;
    }
};

// 具体产品B2
class ProductB2 : public AbstractProductB {
public:
    void use() override {
        std::cout << "Using ProductB2" << std::endl;
    }
};

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

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ProductA1>();
    }

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

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ProductA2>();
    }

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

// 客户端代码
void clientCode(std::unique_ptr<AbstractFactory> factory) {
    auto productA = factory->createProductA();
    auto productB = factory->createProductB();
    productA->use();
    productB->use();
}

int main() {
    std::cout << "Client: Testing client code with the first factory type:" << std::endl;
    clientCode(std::make_unique<ConcreteFactory1>());

    std::cout << "Client: Testing client code with the second factory type:" << std::endl;
    clientCode(std::make_unique<ConcreteFactory2>());

    return 0;
}

代码解析

抽象产品：AbstractProductA 和 AbstractProductB 是抽象产品接口，定义了产品的行为。
具体产品：ProductA1、ProductA2、ProductB1 和 ProductB2 是具体产品实现类。
抽象工厂：AbstractFactory 是抽象工厂接口，定义了创建产品的方法。
具体工厂：ConcreteFactory1 和 ConcreteFactory2 是具体工厂实现类，分别创建不同的产品族。
客户端代码：clientCode 函数使用抽象工厂接口创建产品，并调用产品的方法。