抽象工厂模式示例代码

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。这种模式通常用于在运行时决定使用哪种具体产品。

以下是一个简单的C++抽象工厂模式的示例：

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

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

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

// 具体工厂1 - 创建类型A的产品
class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<ProductA> createProductA() override {
        return std::make_unique<ConcreteProductA>();
    }
    std::unique_ptr<ProductB> createProductB() override {
        return std::make_unique<ConcreteProductB1>();
    }
};

// 具体工厂2 - 另一种类型的创建
class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<ProductA> createProductA() override {
        return std::make_unique<ConcreteProductA>();
    }
    std::unique_ptr<ProductB> createProductB() override {
        return std::make_unique<ConcreteProductB2>();
    }
};

// 具体产品A
class ConcreteProductA : public ProductA {
public:
    void operationA() override {
        std::cout << "Performing Operation A of ConcreteProductA" << std::endl;
    }
};

// 具体产品B1
class ConcreteProductB1 : public ProductB {
public:
    void operationB() override {
        std::cout << "Performing Operation B of ConcreteProductB1" << std::endl;
    }
};

// 具体产品B2
class ConcreteProductB2 : public ProductB {
public:
    void operationB() override {
        std::cout << "Performing Operation B of ConcreteProductB2" << std::endl;
    }
};

int main() {
    AbstractFactory* factory1 = new ConcreteFactory1();
    factory1->createProductA()->operationA(); // 输出 ConcreteProductA 的操作A
    factory1->createProductB()->operationB(); // 输出 ConcreteProductB1 的操作B

    AbstractFactory* factory2 = new ConcreteFactory2();
    factory2->createProductA()->operationA(); // 输出 ConcreteProductA 的操作A
    factory2->createProductB()->operationB(); // 输出 ConcreteProductB2 的操作B

    delete factory1;
    delete factory2;

    return 0;
}

在这个例子中，`AbstractFactory` 是抽象工厂，`ConcreteFactory1` 和 `ConcreteFactory2` 是具体工厂，`ProductA` 和 `ProductB` 是产品接口，`ConcreteProductA`, `ConcreteProductB1`, 和 `ConcreteProductB2` 是具体产品。