C++构造函数如何处理异常？

构造函数抛出异常时对象未完全构造，析构函数不会被调用，因此必须依靠RAII和智能指针确保资源自动释放，防止内存泄漏。

构造函数中处理异常，核心在于确保对象创建失败时资源能够被正确释放，防止内存泄漏和其他潜在问题。直接抛出异常是主要策略，但需要谨慎处理。

C++构造函数中处理异常的最佳实践是使用 RAII (Resource Acquisition Is Initialization) 原则，并在构造函数中捕获并处理可能抛出的异常，或者直接让异常传播出去。

构造函数抛出异常后，会发生什么？如何确保资源安全？

构造函数异常传播与对象状态

构造函数如果抛出异常，对象会被认为构造失败。这意味着：

• 没有构造完成的对象不会调用析构函数。 这是关键！
• 如果在构造函数中分配了任何资源（例如内存、文件句柄等），需要确保这些资源被释放。

问题在于，析构函数不会被调用，所以传统的在析构函数中释放资源的策略失效了。 这也是为什么 RAII 如此重要的原因。

RAII 与智能指针：自动资源管理

RAII 的核心思想是将资源的生命周期与对象的生命周期绑定。当对象创建时获取资源，对象销毁时释放资源。 通过 RAII，即使构造函数抛出异常，也能确保资源得到释放。

智能指针（std::unique_ptr、std::shared_ptr）是实现 RAII 的常用工具。它们在内部管理资源的生命周期，并在对象销毁时自动释放资源。

例如：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int size) : data(new int[size]) {
        if (size <= 0) {
            throw std::invalid_argument("Size must be positive");
        }
        std::cout << "MyClass constructor called" << std::endl;
    }

    ~MyClass() {
        delete[] data;
        std::cout << "MyClass destructor called" << std::endl;
    }

private:
    int* data;
};

class MyClassRAII {
public:
    MyClassRAII(int size) : data(std::unique_ptr<int[]>(new int[size])) {
        if (size <= 0) {
            throw std::invalid_argument("Size must be positive");
        }
        std::cout << "MyClassRAII constructor called" << std::endl;
    }

    ~MyClassRAII() {
        std::cout << "MyClassRAII destructor called" << std::endl;
    }

private:
    std::unique_ptr<int[]> data;
};


int main() {
    try {
        MyClass obj(0); // This will throw an exception
    } catch (const std::exception& e) {
        std::cerr << "Exception caught: " << e.what() << std::endl;
    }

    try {
        MyClassRAII obj2(0); // This will throw an exception
    } catch (const std::exception& e) {
        std::cerr << "Exception caught: " << e.what() << std::endl;
    }

    return 0;
}

在这个例子中，如果 MyClass 的构造函数抛出异常，data 指针指向的内存将不会被释放，导致内存泄漏。而 MyClassRAII 使用 std::unique_ptr 管理内存，即使构造函数抛出异常，unique_ptr 也会自动释放内存。

函数 try 块：捕获构造函数初始化列表中的异常

构造函数可以使用函数 try 块来捕获构造函数初始化列表中的异常。这允许你在构造函数体外部捕获异常，并执行清理操作。

#include <iostream>

class MyClass {
public:
    MyClass(int value)
    try : member1(value), member2(calculate(value)) {
        // Constructor body
        std::cout << "MyClass constructor completed" << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Exception caught in constructor: " << e.what() << std::endl;
        // Perform cleanup here
        throw; // Re-throw the exception
    }

private:
    int member1;
    int member2;

    int calculate(int value) {
        if (value < 0) {
            throw std::invalid_argument("Value must be non-negative");
        }
        return value * 2;
    }
};

int main() {
    try {
        MyClass obj(-1);
    } catch (const std::exception& e) {
        std::cerr << "Exception caught in main: " << e.what() << std::endl;
    }
    return 0;
}

在这个例子中，calculate 函数可能会抛出异常。函数 try 块允许在构造函数初始化列表和构造函数体中捕获异常。注意，捕获到异常后通常需要重新抛出，以防止对象被错误地认为构造成功。

构造函数中的异常规范（C++11 之后已弃用）

在 C++11 之前，可以使用异常规范来声明函数可能抛出的异常。但是，异常规范在 C++11 中已被弃用，并在 C++17 中被移除。建议使用 noexcept 说明符来指定函数是否会抛出异常。

避免在析构函数中抛出异常

虽然不在标题范围内，但值得一提的是，绝对要避免在析构函数中抛出异常。如果析构函数抛出异常，而此时另一个异常正在处理中，程序将会调用 std::terminate 立即终止。这是非常危险的，可能导致数据丢失和其他不可预测的行为。 如果析构函数可能抛出异常，应该在析构函数内部捕获并处理异常，而不是让异常传播出去。