设计模式2之c++抽象工厂模式（示例代码）

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

在抽象工厂模式中，一个工厂类可以创建多个产品族，每个产品族包含多个产品。

抽象工厂模式的角色：

1. 抽象工厂（Abstract Factory）：定义了创建产品族的接口。

2. 具体工厂（Concrete Factory）：实现抽象工厂接口，创建具体产品。

3. 抽象产品（Abstract Product）：定义了产品的接口。

4. 具体产品（Concrete Product）：实现抽象产品接口。

抽象工厂模式的优点：

1. 可以保证客户端创建的对象是相互依赖的产品族中的对象，而不是随意组合的产品。

2. 容易扩展，当需要增加一个新的产品族时，只需要增加一个新的具体工厂类即可。

抽象工厂模式的缺点：

1. 增加新的产品族比较困难，需要修改抽象工厂接口和所有的具体工厂类。

2. 增加新的产品等级结构比较困难，需要修改抽象工厂接口和所有的具体工厂类。

抽象工厂模式的应用场景：

1. 当需要创建一系列相关或相互依赖的对象时，可以使用抽象工厂模式。

2. 当需要将一个系统独立于它的产品的创建、组合和表示时，可以使用抽象工厂模式。

3. 当一个系统要求有多个产品族中的一个进行使用，并且不希望暴露它们的实现细节时，可以使用抽象工厂模式。

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

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

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

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

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

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

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

// 抽象工厂
class AbstractFactory {
public:
    virtual ~AbstractFactory() {}
    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();
    AbstractProductA* productA1 = factory1->createProductA();
    AbstractProductB* productB1 = factory1->createProductB();
    productA1->operation(); // ConcreteProductA1 operation
    productB1->operation(); // ConcreteProductB1 operation
    delete factory1;
    delete productA1;
    delete productB1;
    
    // 使用具体工厂2创建产品
    AbstractFactory* factory2 = new ConcreteFactory2();
    AbstractProductA* productA2 = factory2->createProductA();
    AbstractProductB* productB2 = factory2->createProductB();
    productA2->operation(); // ConcreteProductA2 operation
    productB2->operation(); // ConcreteProductB2 operation
    delete factory2;
    delete productA2;
    delete productB2;
    
    return 0;
}

在上面的示例中，我们定义了抽象产品A和B，以及具体产品A1、A2、B1和B2。然后定义了抽象工厂和具体工厂1、2，具体工厂1可以创建产品A1和B1，具体工厂2可以创建产品A2和B2。最后在main函数中，使用具体工厂1和2分别创建产品A和B，并测试其功能。