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

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

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

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

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

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

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

立即学习“C++免费学习笔记（深入）”；

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

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

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

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

智能指针（

std::unique_ptr

std::shared_ptr

学习导航

学习者优质的学习网址导航网站

下载

例如：

#include 
#include 

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(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 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 

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

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

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

noexcept

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

虽然不在标题范围内，但值得一提的是，绝对要避免在析构函数中抛出异常。如果析构函数抛出异常，而此时另一个异常正在处理中，程序将会调用

std::terminate