8. 委托构造函数（C++11）：什么是委托构造函数？如何减少代码重复？委托构造的注意事项。

好，咱们今天聊一个C++11引入的实用特性——委托构造函数。

说实话，我早年写C++的时候，最烦的就是写多个重载构造函数。每个构造函数里都要重复初始化成员变量、调用公共的初始化逻辑。代码一多，改起来就头疼。你想想看，一个类有3个构造函数，每个里面都有一段几乎一样的初始化代码。后来要加一个成员，得改3个地方。漏一个？嗯，bug就来了。

委托构造函数就是来解决这个问题的。

什么是委托构造函数？

说白了，就是让一个构造函数去调用同一个类里的另一个构造函数。这样，公共的初始化逻辑只需要写一次，其他构造函数“委托”给它就行。

语法很简单：在构造函数的初始化列表里，直接调用另一个构造函数。

class Config {
public:
    // 目标构造函数：做真正的初始化工作
    Config(const std::string& path, int timeout)
        : file_path_(path), timeout_(timeout) {
        // 这里可能还有复杂的初始化逻辑
        LoadFromFile();
        ValidateConfig();
    }

    // 委托构造函数：把工作交给上面的构造函数
    Config() : Config("/etc/default.conf", 30) {
        // 这里可以写一些额外的逻辑
        std::cout << "使用默认配置初始化" << std::endl;
    }

    // 另一个委托构造函数
    Config(const std::string& path) : Config(path, 30) {
        std::cout << "使用自定义路径，默认超时" << std::endl;
    }

private:
    std::string file_path_;
    int timeout_;

    void LoadFromFile() { /* ... */ }
    void ValidateConfig() { /* ... */ }
};

你看，Config() 和 Config(const std::string& path) 都没有自己写初始化逻辑，而是直接委托给了 Config(const std::string& path, int timeout)。这样，所有公共的初始化工作都集中在一个地方。

如何减少代码重复？

我在项目中遇到过这样一个场景：一个网络连接类，有5个不同的构造函数。有的传IP和端口，有的传URL，有的传socket描述符。每个构造函数都要做连接、设置超时、注册回调。一开始代码是复制粘贴的，后来改一个超时逻辑，5个地方都要改。有一次漏了一个，线上出了bug，排查了半天。

用委托构造函数重构后，代码变成了这样：

class NetworkConnection {
public:
    // 主构造函数：所有初始化逻辑都在这里
    NetworkConnection(const std::string& host, int port, int timeout_ms)
        : host_(host), port_(port), timeout_ms_(timeout_ms) {
        Connect();
        SetTimeout();
        RegisterCallbacks();
    }

    // 委托：只传host和port，超时用默认值
    NetworkConnection(const std::string& host, int port)
        : NetworkConnection(host, port, 5000) {}

    // 委托：从URL解析host和port
    NetworkConnection(const std::string& url)
        : NetworkConnection(ParseHost(url), ParsePort(url)) {}

    // 委托：从socket fd构造
    NetworkConnection(int fd)
        : NetworkConnection(GetHostByFd(fd), GetPortByFd(fd), 5000) {}

private:
    std::string host_;
    int port_;
    int timeout_ms_;

    // 辅助函数
    static std::string ParseHost(const std::string& url);
    static int ParsePort(const std::string& url);
    static std::string GetHostByFd(int fd);
    static int GetPortByFd(int fd);
};

这样改完，代码量减少了大概40%。更重要的是，以后改初始化逻辑，只需要改一个地方。我个人习惯把最全的那个构造函数作为“主构造函数”，其他都委托给它。

委托构造的注意事项

嗯，这里要注意几个坑。我曾经踩过，说出来都是泪。

1. 不能循环委托

这个很好理解。A委托B，B委托A，编译器会报错。但有些情况是隐式的，比如：

class Bad {
public:
    Bad(int x) : Bad(x, 0) {}  // 委托给 Bad(int, int)
    Bad(int x, int y) : Bad(x) {}  // 又委托回来！循环了！
};

编译器会报错，但有些复杂的间接循环可能不容易一眼看出来。我建议：保持委托链是单向的，且不超过两层。

2. 委托构造函数不能有初始化列表

这是C++11的一个限制。如果你委托了另一个构造函数，就不能再初始化成员变量了。所有成员的初始化都得交给被委托的那个构造函数。

class Example {
public:
    Example(int a, int b) : x_(a), y_(b) {}

    // 错误！不能同时委托和初始化成员
    Example(int a) : Example(a, 0), x_(a) {}  // 编译错误！

    // 正确做法：只委托，不初始化
    Example(int a) : Example(a, 0) {}

private:
    int x_;
    int y_;
};

为什么？因为C++认为，既然你委托了，那么初始化工作就应该由被委托的构造函数统一完成。这样设计是为了避免混乱——到底谁负责初始化哪个成员？

3. 注意执行顺序

委托构造函数的执行顺序是这样的：

1. 先执行被委托的构造函数（主构造函数）的初始化列表
2. 然后执行被委托的构造函数（主构造函数）的函数体
3. 最后执行委托构造函数的函数体

看个例子：

class Logger {
public:
    Logger(const std::string& file, int level)
        : file_(file), level_(level) {
        std::cout << "主构造函数: " << file_ << std::endl;
        OpenFile();
    }

    Logger() : Logger("default.log", 3) {
        std::cout << "委托构造函数" << std::endl;
    }

private:
    std::string file_;
    int level_;
    void OpenFile() { /* ... */ }
};

// 调用 Logger() 时，输出顺序是：
// 主构造函数: default.log
// 委托构造函数

这个顺序很重要。如果你在委托构造函数的函数体里想用某些已经初始化好的资源，没问题——因为主构造函数已经执行完了。但反过来，主构造函数里不能依赖委托构造函数的逻辑。

4. 异常安全

如果被委托的构造函数抛出了异常，那么委托构造函数的函数体就不会执行了。这其实是合理的——初始化都没成功，后面的逻辑自然没必要跑。

class FileReader {
public:
    FileReader(const std::string& path) : path_(path) {
        OpenFile();  // 可能抛出异常
    }

    FileReader() : FileReader("/tmp/default.txt") {
        // 如果上面的 OpenFile() 抛异常，这里不会执行
        std::cout << "默认文件读取器已创建" << std::endl;
    }
};

我个人觉得这个设计是合理的。异常安全方面，你只需要保证被委托的构造函数是异常安全的就行。

知识体系图

下面这张图帮你理清委托构造函数的核心逻辑：

总结

委托构造函数是C++11里一个很实用的特性。它让代码更干净，减少了重复，也降低了维护成本。我个人觉得，凡是类有多个构造函数且它们有公共初始化逻辑的，都应该考虑用委托构造函数重构。

记住几个要点：

• 一个主构造函数做所有初始化，其他构造函数委托给它
• 委托链保持单向，不超过两层
• 委托构造函数不能有初始化列表
• 注意执行顺序和异常安全

嗯，今天就聊到这里。这个特性不难，但用好了能让代码质量提升一个档次。

---