现代 C++ 创建型模式 on Dorkytiger 的小屋

工厂模式

Mon, 01 Jan 0001 00:00:00 +0000

一、为什么需要工厂？（什么时候用）

场景：你有一个基类 Product，多个派生类 ConcreteProductA / ConcreteProductB。客户端要创建产品，但不知道具体类型。

不用工厂：

std::unique_ptr<Product> createProduct(const std::string& type) {
    if (type == "A") return std::make_unique<ConcreteProductA>();
    if (type == "B") return std::make_unique<ConcreteProductB>();
    return nullptr;
}
// ↑ 每次加新产品都要改这个函数，违反了"开闭原则"

二、注册表工厂（最实用的工厂写法）

class ProductFactory {
    // 用 unique_ptr 返回，所有权清晰
    using Creator = std::function<std::unique_ptr<Product>()>;
    std::unordered_map<std::string, Creator> registry_;

public:
    void register_type(const std::string& type, Creator creator) {
        registry_[type] = std::move(creator);
    }

    std::unique_ptr<Product> create(const std::string& type) {
        auto it = registry_.find(type);
        if (it == registry_.end()) return nullptr;
        return it->second();  // 调用注册的创建函数
    }
};

// 使用
ProductFactory factory;
factory.register_type("Circle", [] { return std::make_unique<Circle>(); });
factory.register_type("Square", [] { return std::make_unique<Square>(); });

auto p = factory.create("Circle");  // unique_ptr<Product>

好处：

单例模式

Mon, 01 Jan 0001 00:00:00 +0000

一、C++11 后的正确写法

class Logger {
public:
    static Logger& instance() {
        static Logger inst;  // C++11 起：线程安全的延迟初始化
        return inst;
    }

    void log(const std::string& msg) { /* ... */ }

    // 防止拷贝和移动
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;

private:
    Logger() = default;  // 私有构造函数，禁止外部创建
    ~Logger() = default;
};

为什么 C++11 后是线程安全的？

C++11 规定：函数内的 static 变量初始化是线程安全的，编译器会在初始化前后插入屏障。
等价于 call_once + once_flag 的效果。

二、什么时候真的需要单例？

应该用：

日志系统（整个进程只需一个日志文件写入点）
硬件资源（如串口、NPU 设备，物理上只有一份）
配置管理器（从文件加载一次配置，全局共享）

不该用：

只是为了"方便全局访问"——这是全局变量的代名词，导致隐式依赖、测试困难
如果你发现 instance() 被几十个文件调用，考虑用依赖注入替换

建造者模式（Builder）

Mon, 01 Jan 0001 00:00:00 +0000

一、什么时候用？

场景：构造一个对象需要十几个参数，有些必填、有些可选、有些有依赖关系：

// ❌ 构造函数方式——十几个参数，调用者分不清谁是谁
HttpRequest req("POST", "http://api.example.com/data", 
                10000,  // timeout
                true,   // keepalive
                "gzip", // encoding
                ...);

// ✅ Builder 方式——逐步设置，可读性强
HttpRequest req = HttpRequest::Builder()
    .method("POST")
    .url("http://api.example.com/data")
    .timeout(10000)
    .keepalive(true)
    .encoding("gzip")
    .build();

二、Builder 的现代 C++ 写法

class HttpRequest {
public:
    class Builder {
        std::string method_ = "GET";
        std::string url_;
        int timeout_ = 5000;
        bool keepalive_ = true;
        std::string encoding_ = "utf-8";

    public:
        Builder& method(std::string m) { method_ = std::move(m); return *this; }
        Builder& url(std::string u)    { url_ = std::move(u);   return *this; }
        Builder& timeout(int t)        { timeout_ = t;          return *this; }

        // [[nodiscard]] 防止调用者忘了调用 build()
        [[nodiscard]] HttpRequest build() {
            // 可以在 build 时做参数校验
            if (url_.empty()) throw std::invalid_argument("url required");
            return HttpRequest(std::move(method_), std::move(url_),
                              timeout_, keepalive_, std::move(encoding_));
        }
    };

private:
    HttpRequest(std::string method, std::string url, int timeout,
                bool keepalive, std::string encoding)
        : method_(std::move(method)), url_(std::move(url)),
          timeout_(timeout), keepalive_(keepalive), encoding_(std::move(encoding)) {}
};

关键：Builder 只是中间媒介，build() 才真正构造对象。构造函数的参数可以是 private 的，强制用户通过 Builder 创建。