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

抽象工厂模式是一种设计模式，其主要目的是提供一种方法，用于创建一组相关或依赖的对象，而不需要关心它们的具体类。

C++ 中的抽象工厂模式代码如下：

#include <iostream>
#include <map>

class AbstractProductA
{
public:
    virtual void operationA() = 0;
};

class ProductA1 : public AbstractProductA
{
public:
    void operationA() { std::cout << "ProductA1" << std::endl; }
};

class ProductA2 : public AbstractProductA
{
public:
    void operationA() { std::cout << "ProductA2" << std::endl; }
};

class AbstractProductB
{
public:
    virtual void operationB() = 0;
};

class ProductB1 : public AbstractProductB
{
public:
    void operationB() { std::cout << "ProductB1" << std::endl; }
};

class ProductB2 : public AbstractProductB
{
public:
    void operationB() { std::cout << "ProductB2" << std::endl; }
};

class AbstractFactory
{
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

class Factory1 : public AbstractFactory
{
public:
    AbstractProductA* createProductA() { return new ProductA1; }
    AbstractProductB* createProductB() { return new ProductB1; }
};

class Factory2 : public AbstractFactory
{
public:
    AbstractProductA* createProductA() { return new ProductA2; }
    AbstractProductB* createProductB() { return new ProductB2; }
};

int main()
{
    std::map<int, AbstractFactory*> factories;
    factories[0] = new Factory1;
    factories[1] = new Factory2;

    AbstractProductA* productA = factories[0]->createProductA();
    AbstractProductB* productB = factories[0]->createProductB();
    productA->operationA();
    productB->operationB();

    delete productA;
    delete productB;
    delete factories[0];
    delete factories[1];

    return 0;
}           

抽象工厂模式由以下几个部分组成：

• 抽象产品类（Abstract Product）：它是一个抽象类，它定义了所有具体产品类（Product）的共同点。
• 具体产品类（Concrete Product）：它是抽象产品类的实现，它代表了一种具体的产品。
• 抽象工厂类（Abstract Factory）：它是一个抽象类，它定义了所有具体工厂类（Concrete Factory）的共同点。
• 具体工厂类（Concrete Factory）：它是抽象工厂类的实现，它生产的是一组具体的产品（Product）。
• 客户端（Client）：它是应用程序的入口点，它使用了抽象工厂（Abstract Factory）和抽象产品（Abstract Product）。

抽象工厂模式的优点：

• 可以生成一组相关产品，不需要关心具体的生产过程，降低了客户端代码的复杂度。
• 抽象工厂模式支持设计模式的扩展，可以很容易地扩展新的产品类。
• 通过使用抽象工厂模式，可以隔离产品类，使得客户端代码不需要关心产品类的具体实现。

抽象工厂模式的缺点：

• 代码复杂度比较高，需要定义较多的抽象类和接口。
• 不适用于生产一种产品的场景，需要选择更适合的设计模式。
• 如果需要添加新工厂，需要修改代码，违背了开闭原则。