设计模式-抽象工厂模式（C++）

抽象工厂模式是一种设计模式，它提供了一个接口来创建一系列相关或相互依赖的对象，而无需指定它们具体的类。下面是一个使用 C++ 实现抽象工厂模式的示例：

// 抽象产品类
class AbstractProductA {
public:
    virtual void DoSomething() = 0;
};
 
class AbstractProductB {
public:
    virtual void DoSomething() = 0;
};
 
// 抽象工厂类
class AbstractFactory {
public:
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};
 
// 具体产品 A1 类
class ConcreteProductA1 : public AbstractProductA {
public:
    void DoSomething() override {
        std::cout << "ConcreteProductA1::DoSomething()" << std::endl;
    }
};
 
// 具体产品 A2 类
class ConcreteProductA2 : public AbstractProductA {
public:
    void DoSomething() override {
        std::cout << "ConcreteProductA2::DoSomething()" << std::endl;
    }
};
 
// 具体产品 B1 类
class ConcreteProductB1 : public AbstractProductB {
public:
    void DoSomething() override {
        std::cout << "ConcreteProductB1::DoSomething()" << std::endl;
    }
};
 
// 具体产品 B2 类
class ConcreteProductB2 : public AbstractProductB {
public:
    void DoSomething() override {
        std::cout << "ConcreteProductB2::DoSomething()" << std::endl;
    }
};
 
// 具体工厂类
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() override {
        return new ConcreteProductA1();
    }
 
    AbstractProductB* CreateProductB() override {
        return new ConcreteProductB1();
    }
};
 
class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() override {
        return new ConcreteProductA2();
    }
 
    AbstractProductB* CreateProductB() override {
        return new ConcreteProductB2();
    }
};
 
int main() {
    // 创建具体工厂对象
    AbstractFactory* factory1 = new ConcreteFactory1();
    AbstractFactory* factory2 = new ConcreteFactory2();
 
    // 通过工厂创建产品
    AbstractProductA* productA1 = factory1->CreateProductA();
    AbstractProductA* productA2 = factory2->CreateProductA();
    AbstractProductB* productB1 = factory1->CreateProductB();
    AbstractProductB* productB2 = factory2->CreateProductB();
 
    // 使用产品
    productA1->DoSomething();
    productA2->DoSomething();
    productB1->DoSomething();
    productB2->DoSomething();
 
    // 释放资源
    delete productA1;
    delete productA2;
    delete productB1;
    delete productB2;
    delete factory1;
    delete factory2;
 
    return 0;
}

在上述示例中，我们定义了抽象产品 AbstractProductA 和 AbstractProductB，以及抽象工厂 AbstractFactory。具体的产品类 ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2 继承自抽象产品类，并实现了具体的功能。具体的工厂类 ConcreteFactory1 和 ConcreteFactory2 继承自抽象工厂类，并用于创建相应的具体产品。

在 main 函数中，我们创建了两个具体工厂对象 factory1 和 factory2，然后通过它们创建了具体的产品对象 productA1、productA2、productB1 和 productB2。最后，我们使用这些产品对象执行相应的操作。

通过抽象工厂模式，我们将产品的创建和使用分离，使得系统更加灵活和可扩展。当需要添加新的产品或工厂时，只需要添加相应的具体类并在工厂中进行实现，而不需要修改现有代码的其他部分。