C/C++实现工厂模板设计模式（Factory Pattern)

工厂模式是一种创建型设计模式，它提供了一种创建对象的方式，而无需指定具体的类。工厂模式通过定义一个创建对象的接口，让子类决定实例化哪一个类。工厂模式可以分为简单工厂模式、工厂方法模式和抽象工厂模式。 下面是一个使用C++实现的简单工厂模式的示例： #include #include // 产品基类 class Product { public: virtual void use() = 0; virtual ~Product() = default; }; // 具体产品A class ProductA : public Product { public: void use() override { std::cout « “Using Product A” « std::endl; } }; // 具体产品B class ProductB : public Product { public: void use() override { std::cout « “Using Product B” « std::endl; } }; // 工厂类 class Factory { public: // 创建产品的方法 static std::unique_ptr createProduct(const std::string& type) { if (type == “A”) { return std::make_unique(); } else if (type == “B”) { return std::make_unique(); } else { return nullptr; } } }; int main() { // 使用工厂创建产品A std::unique_ptr productA = Factory::createProduct(“A”); if (productA) { productA->use(); } // 使用工厂创建产品B std::unique_ptr productB = Factory::createProduct(“B”); if (productB) { productB->use(); } return 0; }

代码说明：

1. Product 是产品的基类，定义了产品的接口 use()。
2. ProductA 和 ProductB 是具体的产品类，分别实现了 use() 方法。
3. Factory 是工厂类，提供了一个静态方法 createProduct()，根据传入的参数决定创建哪种产品。
4. 在 main() 函数中，通过工厂类创建了不同的产品，并调用了它们的 use() 方法。

工厂方法模式：

工厂方法模式是对简单工厂模式的进一步抽象，它将工厂类抽象为一个接口，具体的工厂子类负责创建具体的产品。 #include #include // 产品基类 class Product { public: virtual void use() = 0; virtual ~Product() = default; }; // 具体产品A class ProductA : public Product { public: void use() override { std::cout « “Using Product A” « std::endl; } }; // 具体产品B class ProductB : public Product { public: void use() override { std::cout « “Using Product B” « std::endl; } }; // 工厂基类 class Factory { public: virtual std::unique_ptr createProduct() = 0; virtual ~Factory() = default; }; // 具体工厂A class FactoryA : public Factory { public: std::unique_ptr createProduct() override { return std::make_unique(); } }; // 具体工厂B class FactoryB : public Factory { public: std::unique_ptr createProduct() override { return std::make_unique(); } }; int main() { // 使用工厂A创建产品A std::unique_ptr factoryA = std::make_unique(); std::unique_ptr productA = factoryA->createProduct(); productA->use(); // 使用工厂B创建产品B std::unique_ptr factoryB = std::make_unique(); std::unique_ptr productB = factoryB->createProduct(); productB->use(); return 0; }

代码说明：

1. Factory 是工厂基类，定义了一个纯虚函数 createProduct()，具体的工厂子类需要实现这个方法来创建具体的产品。
2. FactoryA 和 FactoryB 是具体的工厂类，分别负责创建 ProductA 和 ProductB 。
3. 在 main() 函数中，通过具体的工厂类创建了不同的产品，并调用了它们的 use() 方法。

抽象工厂模式：

抽象工厂模式是工厂方法模式的扩展，它提供了一个接口用于创建一系列相关或依赖的对象，而无需指定它们的具体类。 #include #include // 产品A基类 class ProductA { public: virtual void use() = 0; virtual ~ProductA() = default; }; // 具体产品A1 class ProductA1 : public ProductA { public: void use() override { std::cout « “Using Product A1” « std::endl; } }; // 具体产品A2 class ProductA2 : public ProductA { public: void use() override { std::cout « “Using Product A2” « std::endl; } }; // 产品B基类 class ProductB { public: virtual void use() = 0; virtual ~ProductB() = default; }; // 具体产品B1 class ProductB1 : public ProductB { public: void use() override { std::cout « “Using Product B1” « std::endl; } }; // 具体产品B2 class ProductB2 : public ProductB { public: void use() override { std::cout « “Using Product B2” « std::endl; } }; // 抽象工厂基类 class AbstractFactory { public: virtual std::unique_ptr createProductA() = 0; virtual std::unique_ptr createProductB() = 0; virtual ~AbstractFactory() = default; }; // 具体工厂1 class ConcreteFactory1 : public AbstractFactory { public: std::unique_ptr createProductA() override { return std::make_unique(); } std::unique_ptr createProductB() override { return std::make_unique(); } }; // 具体工厂2 class ConcreteFactory2 : public AbstractFactory { public: std::unique_ptr createProductA() override { return std::make_unique(); } std::unique_ptr createProductB() override { return std::make_unique(); } }; int main() { // 使用具体工厂1创建产品A1和B1 std::unique_ptr factory1 = std::make_unique(); std::unique_ptr productA1 = factory1->createProductA(); std::unique_ptr productB1 = factory1->createProductB(); productA1->use(); productB1->use(); // 使用具体工厂2创建产品A2和B2 std::unique_ptr factory2 = std::make_unique(); std::unique_ptr productA2 = factory2->createProductA(); std::unique_ptr productB2 = factory2->createProductB(); productA2->use(); productB2->use(); return 0; }

代码说明：

1. ProductA 和 ProductB 是产品基类，定义了产品的接口 use()。
2. ProductA1 , ProductA2 , ProductB1 , ProductB2 是具体的产品类，分别实现了 use() 方法。
3. AbstractFactory 是抽象工厂基类，定义了两个纯虚函数 createProductA() 和 createProductB()，具体的工厂子类需要实现这些方法来创建具体的产品。
4. ConcreteFactory1 和 ConcreteFactory2 是具体的工厂类，分别负责创建 ProductA1 , ProductB1 和 ProductA2 , ProductB2 。
5. 在 main() 函数中，通过具体的工厂类创建了不同的产品，并调用了它们的 use() 方法。 这些示例展示了如何使用C++实现工厂模式的三种变体：简单工厂模式、工厂方法模式和抽象工厂模式。每种模式都有其适用的场景，选择哪种模式取决于具体的需求和设计目标。