16. 委托构造函数与完美转发：构造函数之间转发参数

说实话，C++11 引入委托构造函数的时候，我第一反应是「这不就是偷懒嘛」。但后来在项目里重构一个拥有六七个构造函数的类时，我才真正体会到它的价值。而完美转发和委托构造函数结合，更是让我少写了不少重复代码。

今天我们就来聊聊这两个特性的组合用法。你想想看，当一个类有多个构造函数，它们之间怎么优雅地共享初始化逻辑？

什么是委托构造函数

简单说，就是一个构造函数调用另一个构造函数。C++11 之前，我们通常写一个私有的 init() 函数，然后每个构造函数都调它。但这样有个问题——init() 不能初始化 const 成员，也不能用初始化列表。

委托构造函数解决了这个问题。它允许你在构造函数的初始化列表里，直接调用另一个构造函数。

class Widget {
    int id_;
    std::string name_;
    bool active_;
public:
    // 主构造函数
    Widget(int id, const std::string& name, bool active)
        : id_(id), name_(name), active_(active) {}

    // 委托给主构造函数
    Widget(int id, const std::string& name)
        : Widget(id, name, true) {}  // 默认 active 为 true

    // 再委托一层
    Widget(int id)
        : Widget(id, "default") {}   // 默认 name 为 "default"
};

嗯，这里要注意：委托链不能形成循环。编译器会检查，但最好你自己心里有数。我曾经见过一个同事写了 A 委托 B、B 委托 C、C 又委托 A 的代码，编译直接报错，排查了半天。

委托构造函数的限制

有几个坑我得提醒你：

• 一旦使用了委托构造函数，就不能再用其他成员初始化列表了
• 被委托的构造函数先执行，然后才执行当前构造函数的函数体
• 不能同时委托和初始化成员

// 错误示例
class Bad {
    int x_;
public:
    Bad(int x) : x_(x) {}
    Bad() : Bad(42), x_(0) {}  // 编译错误！不能同时委托和初始化成员
};

说白了，委托构造函数就是「把初始化逻辑交给别人，自己不再插手初始化列表」。

完美转发在构造函数中的应用

现在问题来了：如果构造函数需要转发参数给成员对象，怎么办？比如我们有个 Container 类，里面存了一个 std::vector<int>，我们想支持各种构造方式。

class Container {
    std::vector<int> data_;
public:
    // 直接转发给 vector 的构造函数
    template<typename... Args>
    explicit Container(Args&&... args)
        : data_(std::forward<Args>(args)...) {}
};

这样写，Container(5, 42) 就会构造一个包含 5 个 42 的 vector。但如果你有多个构造函数需要转发呢？

委托构造函数 + 完美转发

我个人习惯的做法是：写一个私有的「终极构造函数」，其他构造函数都委托给它。这个终极构造函数负责处理所有参数的完美转发。

class Config {
    std::string path_;
    int timeout_;
    bool retry_;
public:
    // 公开的便捷构造函数
    Config() : Config("default.cfg", 30, true) {}

    Config(const std::string& path)
        : Config(path, 30, true) {}

    Config(const std::string& path, int timeout)
        : Config(path, timeout, true) {}

    // 终极构造函数 - 私有
private:
    Config(const std::string& path, int timeout, bool retry)
        : path_(path), timeout_(timeout), retry_(retry) {}
};

但如果你需要转发不同类型的参数，比如有的参数是左值、有的是右值，那就得用模板了。

class Logger {
    std::string prefix_;
    std::ostream& stream_;
public:
    // 公开接口
    Logger() : Logger("LOG", std::cout) {}

    template<typename S, typename T>
    Logger(S&& prefix, T&& stream)
        : Logger(std::forward<S>(prefix), std::forward<T>(stream),
                 std::make_index_sequence<0>{}) {}

private:
    // 终极构造函数 - 处理所有转发
    template<typename S, typename T, size_t... Is>
    Logger(S&& prefix, T&& stream, std::index_sequence<Is...>)
        : prefix_(std::forward<S>(prefix)),
          stream_(std::forward<T>(stream)) {}
};

嗯，这个例子有点复杂了。实际项目中我很少把完美转发和委托构造函数嵌套这么深。大多数情况下，简单的值传递就够了。

避坑指南

我曾经在重构一个网络库时，遇到过一个隐蔽的问题。当时我写了一个 Connection 类，它的构造函数需要转发参数给底层的 socket 对象。我用了完美转发，但忘了处理异常安全。

class Connection {
    Socket socket_;
    std::string endpoint_;
public:
    template<typename... Args>
    Connection(Args&&... args)
        : socket_(std::forward<Args>(args)...),
          endpoint_("unknown") {
        // 如果这里抛出异常，socket_ 已经构造完成了
        // 但 endpoint_ 可能还没初始化完
    }
};

这个问题在于：如果委托的构造函数抛出异常，当前构造函数的函数体不会执行，但被委托的构造函数已经完成了。这通常没问题，因为 RAII 会处理好资源。但如果你在函数体里做了额外的操作（比如注册到某个管理器），那就得小心了。

实际项目中的经验

我在一个配置管理模块中用过这个组合。那个模块有 7 个构造函数，分别接受不同的参数组合。如果不用委托构造函数，代码会膨胀到难以维护。

我的做法是：

1. 写一个私有的、接受所有参数的终极构造函数
2. 所有公开构造函数都委托给它
3. 对于需要转发的参数，用模板 + 完美转发

知识体系图

下面这张图展示了委托构造函数与完美转发的核心关系：

总结

委托构造函数和完美转发，说白了就是两个工具的组合。委托构造函数帮你减少重复代码，完美转发帮你保持参数的高效传递。两者结合，可以写出既简洁又高效的构造函数。

我个人建议：

• 优先用委托构造函数来共享初始化逻辑
• 只在需要转发参数给成员对象时，才引入完美转发
• 控制委托链长度，别超过 2 层
• 注意异常安全，用 RAII 管理资源

嗯，今天就聊到这里。记住，代码是写给人看的，偶尔让机器跑一跑。别为了炫技把构造函数写得像天书一样。