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

核心思想

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

解决的问题

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

使用场景

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

优点

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

缺点

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

示例代码

cpp 复制代码

#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 函数使用抽象工厂接口创建产品，并调用产品的方法。

总结

抽象工厂模式通过提供一种方式来创建一系列相关或依赖的对象，确保这些对象是兼容的，并且将客户端代码与具体类解耦。它适用于需要创建产品族的场景，并且易于扩展和维护。然而，它也会增加系统的复杂性，并且在支持新种类的产品时可能需要修改抽象工厂接口及其所有实现类。