简单工厂模式、工厂模式、抽象工厂模式

工厂模式（Factory Pattern）是一种创建对象的设计模式，它提供了一种方法来将对象的创建过程与对象的使用过程分离。工厂模式在软件开发中有广泛的应用，适用于不同的场景和需求。下面是几种常见的工厂模式及其应用场景：

1. 简单工厂模式（Simple Factory Pattern）

简单工厂模式通过一个工厂类来创建对象，根据不同的输入参数返回不同的类的实例。

应用场景：

• 对象创建逻辑简单：当对象的创建逻辑相对简单，且不需要复杂的初始化时，可以使用简单工厂模式。
• 减少客户端依赖：客户端只需依赖工厂类，而不需要依赖具体的实现类，降低了耦合性。

示例代码：

#include <iostream>
#include <memory>

class Product {
public:
    virtual void use() = 0;
    virtual ~Product() = default;
};

class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "Using Product A" << std::endl;
    }
};

class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "Using Product B" << std::endl;
    }
};

class SimpleFactory {
public:
    static std::unique_ptr<Product> createProduct(char type) {
        if (type == 'A') {
            return std::make_unique<ConcreteProductA>();
        } else if (type == 'B') {
            return std::make_unique<ConcreteProductB>();
        } else {
            return nullptr;
        }
    }
};

int main() {
    auto product = SimpleFactory::createProduct('A');
    if (product) {
        product->use();
    }

    product = SimpleFactory::createProduct('B');
    if (product) {
        product->use();
    }

    return 0;
}

2. 工厂方法模式（Factory Method Pattern）

工厂方法模式通过定义一个创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

应用场景：

• 对象创建复杂：当对象的创建过程比较复杂，需要在子类中定制时，可以使用工厂方法模式。
• 增加新产品：当需要增加新产品时，只需添加新的工厂类，不需要修改已有代码，符合开闭原则。

示例代码：

#include <iostream>
#include <memory>

class Product {
public:
    virtual void use() = 0;
    virtual ~Product() = default;
};

class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "Using Product A" << std::endl;
    }
};

class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "Using Product B" << std::endl;
    }
};

class Creator {
public:
    virtual std::unique_ptr<Product> factoryMethod() const = 0;
    virtual ~Creator() = default;
};

class ConcreteCreatorA : public Creator {
public:
    std::unique_ptr<Product> factoryMethod() const override {
        return std::make_unique<ConcreteProductA>();
    }
};

class ConcreteCreatorB : public Creator {
public:
    std::unique_ptr<Product> factoryMethod() const override {
        return std::make_unique<ConcreteProductB>();
    }
};

int main() {
    std::unique_ptr<Creator> creatorA = std::make_unique<ConcreteCreatorA>();
    auto productA = creatorA->factoryMethod();
    productA->use();

    std::unique_ptr<Creator> creatorB = std::make_unique<ConcreteCreatorB>();
    auto productB = creatorB->factoryMethod();
    productB->use();

    return 0;
}

3. 抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式提供一个接口，用于创建一系列相关或互相依赖的对象，而无需指定它们具体的类。

应用场景：

• 产品族：当需要创建一组相关的或相互依赖的对象时，可以使用抽象工厂模式。
• 平台独立：当系统需要独立于产品的创建和表示时，可以使用抽象工厂模式。

示例代码：

#include <iostream>
#include <memory>

// Abstract Product A
class AbstractProductA {
public:
    virtual void use() = 0;
    virtual ~AbstractProductA() = default;
};

class ConcreteProductA1 : public AbstractProductA {
public:
    void use() override {
        std::cout << "Using Product A1" << std::endl;
    }
};

class ConcreteProductA2 : public AbstractProductA {
public:
    void use() override {
        std::cout << "Using Product A2" << std::endl;
    }
};

// Abstract Product B
class AbstractProductB {
public:
    virtual void use() = 0;
    virtual ~AbstractProductB() = default;
};

class ConcreteProductB1 : public AbstractProductB {
public:
    void use() override {
        std::cout << "Using Product B1" << std::endl;
    }
};

class ConcreteProductB2 : public AbstractProductB {
public:
    void use() override {
        std::cout << "Using Product B2" << std::endl;
    }
};

// Abstract Factory
class AbstractFactory {
public:
    virtual std::unique_ptr<AbstractProductA> createProductA() const = 0;
    virtual std::unique_ptr<AbstractProductB> createProductB() const = 0;
    virtual ~AbstractFactory() = default;
};

// Concrete Factory 1
class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() const override {
        return std::make_unique<ConcreteProductA1>();
    }
    std::unique_ptr<AbstractProductB> createProductB() const override {
        return std::make_unique<ConcreteProductB1>();
    }
};

// Concrete Factory 2
class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() const override {
        return std::make_unique<ConcreteProductA2>();
    }
    std::unique_ptr<AbstractProductB> createProductB() const override {
        return std::make_unique<ConcreteProductB2>();
    }
};

int main() {
    std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>();
    auto productA1 = factory1->createProductA();
    auto productB1 = factory1->createProductB();
    productA1->use();
    productB1->use();

    std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>();
    auto productA2 = factory2->createProductA();
    auto productB2 = factory2->createProductB();
    productA2->use();
    productB2->use();

    return 0;
}

小结

• 简单工厂模式：适用于对象创建逻辑简单，减少客户端依赖的场景。
• 工厂方法模式：适用于对象创建复杂，需要在子类中定制，以及需要增加新产品的场景。
• 抽象工厂模式：适用于创建一组相关或相互依赖的对象，以及系统需要独立于产品的创建和表示的场景。

根据具体的需求选择合适的工厂模式，可以提高代码的可维护性和扩展性。