工厂模式：简单工厂模式、工厂方法模式、抽象工厂模式

适用场景

2. 工厂方法模式示例

总结

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种在不指定具体类的情况下创建对象的方式。工厂模式主要用于解决对象的创建问题，通过将对象的创建过程封装在一个工厂类中，使得客户端代码不需要关心对象的具体创建细节，只需要通过工厂类来获取所需的对象实例。

工厂模式的类型

工厂模式通常分为三种类型：

简单工厂模式（Simple Factory Pattern）：
- 简单工厂模式并不是一种严格意义上的设计模式，它更像是一种编程习惯。
- 简单工厂模式将对象的创建过程集中在一个工厂类中，客户端只需要调用工厂类的方法并传递相应的参数，工厂类就会根据参数返回相应的对象实例。
- 优点是客户端代码简洁，但缺点是工厂类集中了所有的对象创建逻辑，随着业务逻辑的复杂化，工厂类可能会变得越来越臃肿。
工厂方法模式（Factory Method Pattern）：
- 工厂方法模式是简单工厂模式的进一步抽象和推广。
- 在工厂方法模式中，每个具体的类都有一个对应的工厂类，工厂类中定义了一个工厂方法，用于创建对应类的实例。
- 这样做的好处是将对象的创建逻辑分散到各个工厂类中，避免了工厂类的臃肿，同时也符合开闭原则（对扩展开放，对修改关闭）。
抽象工厂模式（Abstract Factory Pattern）：
- 抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
- 抽象工厂模式适用于需要创建一组相关或依赖的对象的情况。
- 它通过定义一个抽象工厂接口，具体的工厂类实现这个接口，来创建一系列相关的产品对象。
- 抽象工厂模式能够确保创建的对象之间的一致性，并且易于扩展。

工厂模式的优点

解耦：客户端代码与具体类的创建代码分离，客户端代码只需要依赖工厂接口，而不需要依赖具体的类。
可扩展性：通过增加新的工厂类和产品类，可以很容易地扩展系统，而不需要修改现有代码。
封装性：对象的创建过程被封装在工厂类中，客户端不需要关心对象的创建细节。

工厂模式的缺点

增加了类的数量：工厂模式会增加系统中类的数量，在一定程度上增加了复杂性。
复杂性：对于简单的对象创建，使用工厂模式可能会显得过于复杂。

适用场景

当一个类不知道它所需要的对象的具体类时。
当一个类希望由其子类来指定它所创建的对象时。
当类将创建对象的职责委托给多个帮助子类中的某一个，并且希望将哪一个帮助子类是代理者这一信息局部化时。

1. 简单工厂模式示例

#include <iostream>
#include <memory>// 产品接口
class Product {
public:virtual void use() = 0;virtual ~Product() = default;
};// 具体产品1
class ConcreteProductA : public Product {
public:void use() override {std::cout << "使用产品 A" << std::endl;}
};// 具体产品2
class ConcreteProductB : 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<ConcreteProductA>();} else if (type == "B") {return std::make_unique<ConcreteProductB>();}return nullptr;}
};int main() {auto productA = SimpleFactory::createProduct("A");productA->use(); // 输出: 使用产品 Aauto productB = SimpleFactory::createProduct("B");productB->use(); // 输出: 使用产品 Breturn 0;
}

2. 工厂方法模式示例

#include <iostream>
#include <memory>// 产品接口
class Product {
public:virtual void use() = 0;virtual ~Product() = default;
};// 具体产品 A
class ConcreteProductA : public Product {
public:void use() override {std::cout << "使用产品 A" << std::endl;}
};// 具体产品 B
class ConcreteProductB : public Product {
public:void use() override {std::cout << "使用产品 B" << std::endl;}
};// 工厂接口
class ProductFactory {
public:virtual std::unique_ptr<Product> createProduct() = 0;virtual ~ProductFactory() = default;
};// 具体工厂 A
class ConcreteFactoryA : public ProductFactory {
public:std::unique_ptr<Product> createProduct() override {return std::make_unique<ConcreteProductA>();}
};// 具体工厂 B
class ConcreteFactoryB : public ProductFactory {
public:std::unique_ptr<Product> createProduct() override {return std::make_unique<ConcreteProductB>();}
};int main() {std::unique_ptr<ProductFactory> factoryA = std::make_unique<ConcreteFactoryA>();auto productA = factoryA->createProduct();productA->use(); // 输出: 使用产品 Astd::unique_ptr<ProductFactory> factoryB = std::make_unique<ConcreteFactoryB>();auto productB = factoryB->createProduct();productB->use(); // 输出: 使用产品 Breturn 0;
}

3. 抽象工厂模式示例

#include <iostream>
#include <memory>// 抽象产品 A
class AbstractProductA {
public:virtual void use() = 0;virtual ~AbstractProductA() = default;
};// 抽象产品 B
class AbstractProductB {
public:virtual void use() = 0;virtual ~AbstractProductB() = default;
};// 具体产品 A1
class ConcreteProductA1 : public AbstractProductA {
public:void use() override {std::cout << "使用产品 A1" << std::endl;}
};// 具体产品 A2
class ConcreteProductA2 : public AbstractProductA {
public:void use() override {std::cout << "使用产品 A2" << std::endl;}
};// 具体产品 B1
class ConcreteProductB1 : public AbstractProductB {
public:void use() override {std::cout << "使用产品 B1" << std::endl;}
};// 具体产品 B2
class ConcreteProductB2 : 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 ConcreteFactory1 : public AbstractFactory {
public:std::unique_ptr<AbstractProductA> createProductA() override {return std::make_unique<ConcreteProductA1>();}std::unique_ptr<AbstractProductB> createProductB() override {return std::make_unique<ConcreteProductB1>();}
};// 具体工厂 2
class ConcreteFactory2 : public AbstractFactory {
public:std::unique_ptr<AbstractProductA> createProductA() override {return std::make_unique<ConcreteProductA2>();}std::unique_ptr<AbstractProductB> createProductB() override {return std::make_unique<ConcreteProductB2>();}
};int main() {// 使用工厂 1std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>();auto productA1 = factory1->createProductA();productA1->use(); // 输出: 使用产品 A1auto productB1 = factory1->createProductB();productB1->use(); // 输出: 使用产品 B1// 使用工厂 2std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>();auto productA2 = factory2->createProductA();productA2->use(); // 输出: 使用产品 A2auto productB2 = factory2->createProductB();productB2->use(); // 输出: 使用产品 B2return 0;
}