用C++写一段抽象工厂模式的代码

当使用C++实现抽象工厂模式时，可以按照以下示例代码进行编写：

#include <iostream>
using namespace std;

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

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

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

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

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

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

// 抽象工厂
class AbstractFactory {
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ConcreteProductA1();
    }

    AbstractProductB* createProductB() override {
        return new ConcreteProductB1();
    }
};

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ConcreteProductA2();
    }

    AbstractProductB* createProductB() override {
        return new ConcreteProductB2();
    }
};

int main() {
    // 创建具体工厂1
    AbstractFactory* factory1 = new ConcreteFactory1();
    // 创建产品A1
    AbstractProductA* productA1 = factory1->createProductA();
    productA1->operationA();
    // 创建产品B1
    AbstractProductB* productB1 = factory1->createProductB();
    productB1->operationB();

    // 创建具体工厂2
    AbstractFactory* factory2 = new ConcreteFactory2();
    // 创建产品A2
    AbstractProductA* productA2 = factory2->createProductA();
    productA2->operationA();
    // 创建产品B2
    AbstractProductB* productB2 = factory2->createProductB();
    productB2->operationB();

    delete factory1;
    delete factory2;
    delete productA1;
    delete productB1;
    delete productA2;
    delete productB2;

    return 0;
}

在上述示例中，我们定义了抽象产品A和抽象产品B，以及它们的具体实现类。然后定义了抽象工厂和具体工厂，每个具体工厂负责创建一组相关的产品对象。在`main`函数中，我们可以通过具体工厂来创建具体的产品对象，并调用其方法。

注意，在使用完创建的对象后，需要手动释放内存。这里简单示范了抽象工厂模式的用法，你可以根据实际情况进行扩展和修改。