构造函数中的异常处理：风险、RAII与两段式构造

大家好，我是你们的老朋友。今天我们来聊一个让很多C++开发者头疼的话题——构造函数里抛出异常。

说实话，我早年刚入行时，觉得构造函数就是用来初始化成员的，哪来那么多讲究？直到有一次，我在一个支付系统的核心模块里，因为构造函数异常没处理好，导致内存泄漏，线上服务直接挂了。嗯，从那以后，我再也不敢轻视这个话题了。

一、构造函数中抛出异常的风险

先问大家一个问题：构造函数里能不能抛异常？

技术上当然可以。但问题是——抛出异常后，对象到底算不算构造完成？

答案很明确：不算。C++标准规定，如果构造函数通过异常退出，那么该对象的析构函数不会被调用。

这就带来了一个致命风险：

举个例子，我见过这样的代码：

class DatabaseConnection {
public:
    DatabaseConnection(const std::string& connStr) {
        handle_ = open_connection(connStr);  // 打开数据库连接
        if (!handle_) {
            throw std::runtime_error("连接失败");
        }
        // 假设这里又分配了一些内部缓冲区
        buffer_ = new char[1024];
        // 如果这里抛异常，handle_ 就泄漏了！
        if (some_condition) {
            throw std::runtime_error("初始化失败");
        }
    }
    ~DatabaseConnection() {
        close_connection(handle_);
        delete[] buffer_;
    }
private:
    void* handle_;
    char* buffer_;
};

你看，如果构造函数在分配 buffer_ 之后抛出异常，handle_ 对应的数据库连接就永远关不掉了。析构函数根本不会执行。

这就是我常说的：构造函数里的异常，就像一颗定时炸弹。你永远不知道它会在哪个资源分配点上爆炸。

二、RAII与异常安全

那怎么解决这个问题？答案就是——RAII（Resource Acquisition Is Initialization）。

RAII 的核心思想很简单：把资源管理交给对象的生命周期。说白了，就是让资源在构造函数中获取，在析构函数中释放。这样，即使构造函数中途抛出异常，已经构造完成的成员对象也会自动调用其析构函数。

我个人习惯用智能指针和标准库容器来管理资源，而不是手动 new/delete：

class DatabaseConnection {
public:
    DatabaseConnection(const std::string& connStr) 
        : handle_(open_connection(connStr), &close_connection)  // 使用 unique_ptr 自定义删除器
        , buffer_(std::make_unique<char[]>(1024))
    {
        if (!handle_) {
            throw std::runtime_error("连接失败");
        }
        // 即使这里抛异常，handle_ 和 buffer_ 也会自动释放
        if (some_condition) {
            throw std::runtime_error("初始化失败");
        }
    }
    // 不需要自定义析构函数了！
private:
    std::unique_ptr<void, decltype(&close_connection)> handle_;
    std::unique_ptr<char[]> buffer_;
};

你看，这样改造后，即使构造函数中途抛出异常，handle_ 和 buffer_ 也会因为 unique_ptr 的析构函数而自动释放。这就是 RAII 的威力。

三、两段式构造

说到两段式构造，我得先坦白——我早期写 C++ 时，经常用这种模式。因为那时候对异常安全理解不够深。

两段式构造，说白了就是把对象的初始化和资源分配分开：

1. 第一阶段：构造函数只做简单的成员初始化，不分配可能失败的外部资源
2. 第二阶段：调用一个专门的 init() 或 open() 函数来分配资源

代码大概长这样：

class DatabaseConnection {
public:
    DatabaseConnection() : handle_(nullptr), buffer_(nullptr) {
        // 第一阶段：只初始化成员
    }
    
    bool init(const std::string& connStr) {
        // 第二阶段：分配资源
        handle_ = open_connection(connStr);
        if (!handle_) return false;
        
        buffer_ = new char[1024];
        return true;
    }
    
    ~DatabaseConnection() {
        if (handle_) close_connection(handle_);
        delete[] buffer_;
    }
    
private:
    void* handle_;
    char* buffer_;
};

这种模式的好处是：异常不会在构造函数中发生，资源分配失败可以通过返回值处理。但缺点也很明显：

• 对象可能处于「半初始化」状态，使用者必须记得调用 init()
• 如果忘记调用 init() 就使用对象，行为未定义
• 不符合 RAII 的哲学

四、知识体系总览

为了让大家更直观地理解本章的知识结构，我画了一张图：

五、避坑指南

最后，我把自己踩过的坑总结一下，希望能帮大家少走弯路：

记住一句话：构造函数要简单，析构函数要安全。如果你能做到这两点，异常处理就成功了一大半。

好了，今天就聊到这里。希望这些经验对你有帮助。