c++中怎么实现一个工厂模式_c++工厂设计模式实现方法

工厂模式通过解耦对象创建过程提升代码灵活性，C++中常用简单工厂、工厂方法、抽象工厂和注册式工厂四种方式实现，分别适用于不同复杂度与扩展需求场景。

工厂模式是一种创建型设计模式，用来解耦对象的创建过程。在C++中，通过基类指针和多态机制，结合一个“工厂”函数或类来决定具体创建哪个派生类对象，从而避免在代码中直接使用new硬编码对象类型。

1. 简单工厂模式（Simple Factory）

简单工厂不是严格意义上的设计模式，但很实用。它用一个单独的工厂函数根据参数创建不同类型的对象。

#include <iostream>
#include <memory>

// 基类
class Product {
public:
    virtual ~Product() = default;
    virtual void use() const = 0;
};

// 具体产品类
class ConcreteProductA : public Product {
public:
    void use() const override {
        std::cout << "Using Product A\n";
    }
};

class ConcreteProductB : public Product {
public:
    void use() const override {
        std::cout << "Using Product B\n";
    }
};

// 工厂类（静态方法）
class SimpleFactory {
public:
    static std::unique_ptr<Product> createProduct(char type) {
        if (type == 'A') {
            return std::make_unique<ConcreteProductA>();
        } else if (type == 'B') {
            return std::make_unique<ConcreteProductB>();
        }
        return nullptr;
    }
};

使用方式：

Cliclic AI

Cliclic商品背景图编辑器是一款功能强大的AI工具，帮助用户快速生成具有吸引力的商品图背景。

下载

auto product = SimpleFactory::createProduct('A');
if (product) product->use(); // 输出：Using Product A

2. 工厂方法模式（Factory Method）

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使类的实例化延迟到子类。

立即学习“C++免费学习笔记（深入）”；

// 工厂基类
class Factory {
public:
    virtual ~Factory() = default;
    virtual std::unique_ptr<Product> createProduct() const = 0;
};

// 具体工厂
class ConcreteFactoryA : public Factory {
public:
    std::unique_ptr<Product> createProduct() const override {
        return std::make_unique<ConcreteProductA>();
    }
};

class ConcreteFactoryB : public Factory {
public:
    std::unique_ptr<Product> createProduct() const override {
        return std::make_unique<ConcreteProductB>();
    }
};

使用方式：

std::unique_ptr<Factory> factory = std::make_unique<ConcreteFactoryA>();
auto product = factory->createProduct();
product->use(); // 输出：Using Product A

3. 抽象工厂模式（Abstract Factory）

用于创建一系列相关或依赖对象，而无需指定具体类。

// 产品族：另一个抽象产品
class Button {
public:
    virtual ~Button() = default;
    virtual void render() const = 0;
};

class WinButton : public Button {
public:
    void render() const override {
        std::cout << "Rendering Windows button\n";
    }
};

class MacButton : public Button {
public:
    void render() const override {
        std::cout << "Rendering Mac button\n";
    }
};

// 抽象工厂
class GUIFactory {
public:
    virtual ~GUIFactory() = default;
    virtual std::unique_ptr<Product> createProduct() const = 0;
    virtual std::unique_ptr<Button> createButton() const = 0;
};

// 具体工厂：Windows 风格
class WinFactory : public GUIFactory {
public:
    std::unique_ptr<Product> createProduct() const override {
        return std::make_unique<ConcreteProductA>();
    }
    std::unique_ptr<Button> createButton() const override {
        return std::make_unique<WinButton>();
    }
};

// 具体工厂：Mac 风格
class MacFactory : public GUIFactory {
public:
    std::unique_ptr<Product> createProduct() const override {
        return std::make_unique<ConcreteProductB>();
    }
    std::unique_ptr<Button> createButton() const override {
        return std::make_unique<MacButton>();
    }
};

使用方式：

std::unique_ptr<GUIFactory> factory = std::make_unique<WinFactory>();
auto product = factory->createProduct();
auto button = factory->createButton();
product->use();   // Using Product A
button->render(); // Rendering Windows button

4. 注册式工厂（Map + 函数指针）

更灵活的方式，通过注册类名与构造函数映射，实现动态扩展。

#include <map>
#include <functional>

class ProductFactory {
public:
    using Creator = std::function<std::unique_ptr<Product>()>;
    static ProductFactory& getInstance() {
        static ProductFactory instance;
        return instance;
    }

    void registerProduct(const std::string& name, Creator creator) {
        creators[name] = creator;
    }

    std::unique_ptr<Product> create(const std::string& name) {
        auto it = creators.find(name);
        return it != creators.end() ? it->second() : nullptr;
    }

private:
    std::map<std::string, Creator> creators;
};

// 注册产品
static bool registerProducts() {
    ProductFactory::getInstance().registerProduct("A", []() {
        return std::make_unique<ConcreteProductA>();
    });
    ProductFactory::getInstance().registerProduct("B", []() {
        return std::make_unique<ConcreteProductB>();
    });
    return true;
}

static bool registered = registerProducts(); // 自动注册

使用方式：

auto product = ProductFactory::getInstance().create("A");
if (product) product->use(); // Using Product A