设计模式：工程模式

大家好，欢迎来到IT知识分享网。

C++设计模式：工程模式

设计模式是解决软件设计中常见问题的典型解决方案。工程模式（Factory Pattern）是创建型设计模式之一，旨在处理对象创建的复杂性，使代码更具可扩展性和可维护性。本文将介绍工程模式的基本概念、类型以及如何在C++中实现。

什么是工程模式？

工程模式是一种通过工厂方法来创建对象的设计模式，避免了直接使用new关键字来实例化对象。它将对象的创建过程封装在一个工厂类中，使得代码更加灵活和可维护。

工程模式主要分为三种类型：

1. 简单工厂模式（Simple Factory Pattern）
   • 也称为静态工厂方法模式，使用一个单一的工厂类根据条件创建对象。
2. 工厂方法模式（Factory Method Pattern）
   • 定义一个创建对象的接口，但让子类决定实例化哪个类。
3. 抽象工厂模式（Abstract Factory Pattern）
   • 提供一个创建一系列相关或依赖对象的接口，而无需指定它们的具体类。

简单工厂模式

简单工厂模式是工程模式中最简单的一种。它通过一个静态方法根据不同的参数创建不同的对象。

#include <iostream> #include <memory> // 产品抽象基类 class Product {     public: virtual void show() = 0; virtual ~Product() = default; }; // 具体产品类A class ConcreteProductA : public Product {     public: void show() override {     std::cout << "ConcreteProductA" << std::endl; } }; // 具体产品类B class ConcreteProductB : public Product {     public: void show() override {     std::cout << "ConcreteProductB" << std::endl; } }; // 工厂类 class SimpleFactory {     public: enum class ProductType {     A, B }; static std::unique_ptr<Product> createProduct(ProductType type) {     switch (type) {     case ProductType::A: return std::make_unique<ConcreteProductA>(); case ProductType::B: return std::make_unique<ConcreteProductB>(); default: return nullptr; } } }; int main() {     auto productA = SimpleFactory::createProduct(SimpleFactory::ProductType::A); productA->show(); auto productB = SimpleFactory::createProduct(SimpleFactory::ProductType::B); productB->show(); return 0; } 

工厂方法模式

工厂方法模式通过定义一个创建对象的接口，将具体的创建过程延迟到子类中。

#include <iostream> #include <memory> // 产品抽象基类 class Product {     public: virtual void show() = 0; virtual ~Product() = default; }; // 具体产品类A class ConcreteProductA : public Product {     public: void show() override {     std::cout << "ConcreteProductA" << std::endl; } }; // 具体产品类B class ConcreteProductB : public Product {     public: void show() override {     std::cout << "ConcreteProductB" << std::endl; } }; // 工厂基类 class Factory {     public: virtual std::unique_ptr<Product> createProduct() = 0; virtual ~Factory() = default; }; // 具体工厂类A class ConcreteFactoryA : public Factory {     public: std::unique_ptr<Product> createProduct() override {     return std::make_unique<ConcreteProductA>(); } }; // 具体工厂类B class ConcreteFactoryB : public Factory {     public: std::unique_ptr<Product> createProduct() override {     return std::make_unique<ConcreteProductB>(); } }; int main() {     std::unique_ptr<Factory> factoryA = std::make_unique<ConcreteFactoryA>(); auto productA = factoryA->createProduct(); productA->show(); std::unique_ptr<Factory> factoryB = std::make_unique<ConcreteFactoryB>(); auto productB = factoryB->createProduct(); productB->show(); return 0; } 

抽象工厂模式

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

#include <iostream> #include <memory> // 抽象产品A类 class AbstractProductA {     public: virtual void show() = 0; virtual ~AbstractProductA() = default; }; // 抽象产品B类 class AbstractProductB {     public: virtual void display() = 0; virtual ~AbstractProductB() = default; }; // 具体产品A1 class ConcreteProductA1 : public AbstractProductA {     public: void show() override {     std::cout << "ConcreteProductA1" << std::endl; } }; // 具体产品A2 class ConcreteProductA2 : public AbstractProductA {     public: void show() override {     std::cout << "ConcreteProductA2" << std::endl; } }; // 具体产品B1 class ConcreteProductB1 : public AbstractProductB {     public: void display() override {     std::cout << "ConcreteProductB1" << std::endl; } }; // 具体产品B2 class ConcreteProductB2 : public AbstractProductB {     public: void display() override {     std::cout << "ConcreteProductB2" << 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() {     std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>(); auto productA1 = factory1->createProductA(); auto productB1 = factory1->createProductB(); productA1->show(); productB1->display(); std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>(); auto productA2 = factory2->createProductA(); auto productB2 = factory2->createProductB(); productA2->show(); productB2->display(); return 0; } 

总结

工程模式通过将对象的创建过程封装在工厂类中，使代码更加灵活和易于维护。本文介绍了三种工程模式的实现方法：简单工厂模式、工厂方法模式和抽象工厂模式。每种模式都有其适用场景和优缺点，开发者可以根据具体需求选择合适的模式应用于项目中。通过合理地使用设计模式，可以提高代码的可读性、可维护性和扩展性。