C++如何实现一个工厂模式?(设计模式示例)

工厂模式的核心是封装对象创建过程,避免直接new;C++中常用简单工厂和工厂方法模式;通过抽象产品接口Product及ConcreteProductA等具体实现,实现多态与解耦。

工厂模式的核心是把对象的创建过程封装起来,让调用方不直接 new 具体类,而是通过一个统一接口获取实例。C++ 中常用的是简单工厂(非 GoF 标准但实用)和工厂方法(标准 GoF 模式),下面用一个清晰、可运行的例子说明。

定义抽象产品接口

所有具体产品都要继承这个基类,保证多态性:

class Product {
public:
    virtual ~Product() = default;
    virtual void operation() const = 0;
};

实现多个具体产品

每个子类提供自己的行为逻辑:

class ConcreteProductA : public Product {
public:
    void operation() const override {
        std::cout << "ConcreteProductA executed.\n";
    }
};

class ConcreteProductB : public Product {
public:
    void operation() const override {
        std::cout << "ConcreteProductB executed.\n";
    }
};

实现简单工厂类

工厂负责根据参数决定创建哪个具体类型,返回智能指针更安全:

class SimpleFactory {
public:
    enum class ProductType {
        A, B
    };

    static std::unique_ptr createProduct(ProductType type) {
        switch (type) {
            case ProductType::A:
                return std::make_unique();
            case ProductType::B:
                return std::make_unique();
            default:
                return nullptr;
        }
    }
};

使用方式简洁明了:

auto p1 = SimpleFactory::createProduct(SimpleFactory::ProductType::A);
auto p2 = SimpleFactory::createProduct(SimpleFactory::ProductType::B);
if (p1) p1->operation(); // 输出 A 的行为
if (p2) p2->operation(); // 输出 B 的行为

进阶:工厂方法模式(支持扩展)

当需要支持新增产品且不想修改原有工厂时,可以定义抽象工厂接口:

class Creator {
public:
    virtual std::unique_ptr factoryMethod() const = 0;
    void someOperation() const {
        auto product = factoryMethod();
        if (product) product->operation();
    }
};

class ConcreteCreatorA : public Creator {
public:
    std::unique_ptr factoryMethod() const override {
        return std::make_unique();
    }
};

class ConcreteCreatorB : public Creator {
public:
    std::unique_ptr factoryMethod() const override {
        return std::make_unique();
    }
};

这样每新增一类产品,只需新增一对 具体产品 + 具体工厂,完全符合开闭原则。

基本上就这些。简单工厂适合内部逻辑固定、变化少的场景;工厂方法更适合框架或插件化设计。关键点在于解耦创建与使用,避免硬编码 new,便于测试和替换实现。