Factory 模式

Factory模式是一种创建型设计模式，它可以根据不同的参数或条件，创建并返回不同类型的对象。Factory模式的优点是可以将对象的创建过程封装起来，避免直接使用new操作符，提高了代码的可维护性和可扩展性。Factory模式的缺点是可能会导致类的数量增加，增加了系统的复杂度。

Factory模式适用于以下场景：

• 当需要根据不同的输入或配置，创建不同类型或属性的对象时，可以使用Factory模式。
• 当需要将对象的创建过程与对象的使用过程分离时，可以使用Factory模式。
• 当需要在运行时动态地创建对象时，可以使用Factory模式。

Factory模式有以下几种常见的变体：

• 简单工厂（Simple Factory）：一个工厂类根据传入的参数，决定创建哪一种产品类的实例。
• 工厂方法（Factory Method）：定义一个抽象的工厂接口，让子类实现具体的工厂方法，每个子类负责创建一种产品类的实例。
• 抽象工厂（Abstract Factory）：定义一个抽象的工厂接口，让子类实现具体的工厂方法，每个子类负责创建一系列相关或相互依赖的产品类的实例。

// 工厂模式示例
#include <iostream>
using namespace std;

// 抽象产品类
class Product {
public:
    virtual void use() = 0;
    virtual ~Product() {}
};

// 具体产品类A
class ProductA : public Product {
public:
    void use() {
        cout << "ProductA in use." << endl;
    }
};

// 具体产品类B
class ProductB : public Product {
public:
    void use() {
        cout << "ProductB in use." << endl;
    }
};

// 工厂类
class Factory {
public:
    // 工厂方法，返回抽象产品类指针
    virtual Product* createProduct() = 0;
    virtual ~Factory() {}
};

// 具体工厂类A
class FactoryA : public Factory {
public:
    // 实现工厂方法，返回具体产品类A指针
    Product* createProduct() {
        return new ProductA();
    }
};

// 具体工厂类B
class FactoryB : public Factory {
public:
    // 实现工厂方法，返回具体产品类B指针
    Product* createProduct() {
        return new ProductB();
    }
};

int main() {
    // 创建具体工厂类A对象
    Factory* factoryA = new FactoryA();
    // 通过工厂A创建具体产品类A对象
    Product* productA = factoryA->createProduct();
    // 使用产品A
    productA->use();
    delete productA;
    delete factoryA;

    // 创建具体工厂类B对象
    Factory* factoryB = new FactoryB();
    // 通过工厂B创建具体产品类B对象
    Product* productB = factoryB->createProduct();
    // 使用产品B
    productB->use();
    delete productB;
    delete factoryB;

    return 0;
}