设计模式：工程模式

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;
}

总结

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