[特殊字符] 工厂模式的三种类型

工厂模式的三种类型

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

简单工厂模式通过一个工厂类，根据提供的信息决定创建哪一种产品类的实例虽然它不属于 GoF 的 23 种设计模式之一，但在实际开发中被广泛使用

示例代码：

#include 
#include 
#include 

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

// 具体产品A
class ProductA : public Product {
public:
    void use() override {
        std::cout << "使用产品A" << std::endl;
    }
};

// 具体产品B
class ProductB : public Product {
public:
    void use() override {
        std::cout << "使用产品B" << std::endl;
    }
};

// 简单工厂
class SimpleFactory {
public:
    static std::unique_ptr<Product> createProduct(const std::string& type) {
        if (type == "A") {
            return std::make_unique<ProductA>();
        } else if (type == "B") {
            return std::make_unique<ProductB>();
        } else {
            return nullptr;
        }
    }
};

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

优点：

-封装了对象的创建过程，客户端无需知道具体的创建细节便于管理和维护对象的创建

缺点：

-当需要添加新的产品时，需要修改工厂类，违反了开闭原则

---

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

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

示例代码：

#include 
#include 

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

// 具体产品A
class ProductA : public Product {
public:
    void use() override {
        std::cout << "使用产品A" << std::endl;
    }
};

// 具体产品B
class ProductB : public Product {
public:
    void use() override {
        std::cout << "使用产品B" << std::endl;
    }
};

// 抽象工厂
class Factory {
public:
    virtual std::unique_ptr<Product> createProduct() = 0;
    virtual ~Factory() = default;
};

// 具体工厂A
class FactoryA : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ProductA>();
    }
};

// 具体工厂B
class FactoryB : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ProductB>();
    }
};

int main() {
    std::unique_ptr<Factory> factory = std::make_unique<FactoryA>();
    auto product = factory->createProduct();
    product->use();
    return 0;
}

优点：

-符合开闭原则，添加新产品时无需修改现有代码客户端代码与具体产品解耦，增强了系统的灵活性和可扩展性

缺点：

-每添加一个产品类，就需要增加一个对应的工厂类，增加了系统的复杂度

---

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

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类它通过多个抽象产品类来实现产品族的创建

示例代码：

#include 
#include 

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

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

// 具体产品A1
class ProductA1 : public AbstractProductA {
public:
    void use() override {
        std::cout << "使用产品A1" << std::endl;
    }
};

// 具体产品B1
class ProductB1 : public AbstractProductB {
public:
    void use() override {
        std::cout << "使用产品B1" << std::endl;
    }
};

// 具体产品A2
class ProductA2 : public AbstractProductA {
public:
    void use() override {
        std::cout << "使用产品A2" << std::endl;
    }
};

// 具体产品B2
class ProductB2 : public AbstractProductB {
public:
    void use() override {
        std::cout << "使用产品B2" << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual std::unique_ptr<AbstractProductA> createProductA() = 0;
    virtual std::unique_ptr<AbstractProductB> createProductB() = 0;
    virtual ~AbstractFactory() = default;
};

// 具体工厂1
class Factory1 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ProductA1>();
    }
    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ProductB1>();
    }
};

// 具体工厂2
class Factory2 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ProductA2>();
    }
    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ProductB2>();
    }
};

int main() {
    std::unique_ptr<AbstractFactory> factory = std::make_unique<Factory1>();
    auto productA = factory->createProductA();
    auto productB = factory->createProductB();
    productA->use