抽象工厂方法模式c++

抽象工厂方法模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一个接口，用于创建一系列相关或依赖对象的家族，而无需指定它们具体的类。

在 C++ 中，抽象工厂方法模式通常通过定义一个抽象基类来实现。这个抽象基类定义了一系列纯虚函数，用于创建不同类型的产品对象。然后，针对不同的产品族，创建具体的工厂类，这些工厂类实现了抽象基类中定义的纯虚函数，用于创建具体的产品对象。

以下是一个简单的抽象工厂方法模式的示例代码：

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

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

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

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

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

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

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

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

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

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

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

int main() {
    AbstractFactory* factory1 = new ConcreteFactory1();
    AbstractProductA* productA1 = factory1->createProductA();
    AbstractProductB* productB1 = factory1->createProductB();
    productA1->operationA(); // 输出：ConcreteProductA1::operationA()
    productB1->operationB(); // 输出：ConcreteProductB1::operationB()

    AbstractFactory* factory2 = new ConcreteFactory2();
    AbstractProductA* productA2 = factory2->createProductA();
    AbstractProductB* productB2 = factory2->createProductB();
    productA2->operationA(); // 输出：ConcreteProductA2::operationA()
    productB2->operationB(); // 输出：ConcreteProductB2::operationB()

    return 0;
}

在上面的示例代码中，我们定义了两个抽象产品类 `AbstractProductA` 和 `AbstractProductB`，以及四个具体产品类 `ConcreteProductA1`、`ConcreteProductA2`、`ConcreteProductB1` 和 `ConcreteProductB2`。然后，我们定义了一个抽象工厂类 `AbstractFactory`，它包含两个纯虚函数，用于创建不同类型的产品对象。最后，我们定义了两个具体工厂类 `ConcreteFactory1` 和 `ConcreteFactory2`，它们分别实现了 `AbstractFactory` 中定义的纯虚函数，用于创建具体的产品对象。

在 `main` 函数中，我们首先创建了一个 `ConcreteFactory1` 对象，然后使用它创建了一个 `ConcreteProductA1` 和一个 `ConcreteProductB1` 对象，并调用了它们的成员函数。然后，我们创建了一个 `ConcreteFactory2` 对象，使用它创建了一个 `ConcreteProductA2` 和一个 `ConcreteProductB2` 对象，并调用了它们的成员函数。

通过这种方式，我们可以轻松地创建一系列相关或依赖对象的家族，并且无需指定它们具体的类。