C++析构函数中抛出异常问题详解与解决方案

C++析构函数异常处理解析
原创 于 2025-12-06 07:30:00 发布 · 250 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言 #算法

C++析构函数中抛出异常问题详解与解决方案

一、问题概述

析构函数中抛出异常是C++编程中极其危险的行为，主要问题包括：

  1. 程序终止：如果在栈展开过程中析构函数抛出异常，程序会调用std::terminate()
  2. 资源泄漏：异常中断资源释放过程
  3. 未定义行为：破坏异常处理机制
  4. 调试困难：异常信息丢失，难以追踪根本原因

二、C++标准规定

2.1 标准规则

根据C++标准（§15.2/3）：

  • 如果异常正在传播时，从析构函数抛出第二个异常，程序将终止
  • 析构函数默认标记为noexcept(true)（C++11起）
class Resource {
public:
    ~Resource() {
        // C++11起：隐式声明为 noexcept
        // 如果这里抛出异常，程序可能终止
    }
};

三、问题场景分析

3.1 栈展开过程中的异常

// ❌ 危险示例：析构函数在栈展开中抛出异常
#include <iostream>
#include <stdexcept>

class DangerousResource {
public:
    DangerousResource(const char* name) : name_(name) {
        std::cout << "Acquiring: " << name_ << std::endl;
    }
    
    ~DangerousResource() {
        std::cout << "Releasing: " << name_ << std::endl;
        // 危险：可能在栈展开时抛出异常
        if (std::uncaught_exceptions() > 0) {
            std::cout << "WARNING: Exception already active!" << std::endl;
        }
        throw std::runtime_error("Error in ~DangerousResource()");
    }
    
private:
    const char* name_;
};

void risky_function() {
    DangerousResource res1("Resource1");
    DangerousResource res2("Resource2");
    throw std::runtime_error("Primary exception");
}

int main() {
    try {
        risky_function();
    } catch (const std::exception& e) {
        std::cout << "Caught: " << e.what() << std::endl;
        // 实际上程序可能在析构函数中终止
    }
    return 0;
}
// 输出可能：
// Acquiring: Resource1
// Acquiring: Resource2
// Releasing: Resource2
// terminate called after throwing an instance of 'std::runtime_error'
// 程序终止！

3.2 容器元素析构异常

// ❌ 危险示例：容器中的对象析构抛出异常
#include <vector>
#include <iostream>
#include <memory>

class Element {
public:
    Element(int id) : id_(id) {
        std::cout << "Element " << id_ << " created" << std::endl;
    }
    
    ~Element() noexcept(false) {  // 错误地关闭noexcept
        std::cout << "Element " << id_ << " destroying" << std::endl;
        if (id_ == 2) {
            throw std::runtime_error("Failed to destroy element 2");
        }
    }
    
private:
    int id_;
};

int main() {
    try {
        std::vector<Element> elements;
        elements.reserve(5);
        
        for (int i = 0; i < 5; ++i) {
            elements.emplace_back(i);
        }
        
        // vector析构时会逐个销毁元素
        // 当元素2抛出异常时，其他元素可能不会被正确销毁
    } catch (const std::exception& e) {
        std::cout << "Caught: " << e.what() << std::endl;
    }
    return 0;
}
// 问题：元素3、4、5可能泄漏资源

3.3 继承体系中的析构函数

// ❌ 危险示例：基类和派生类析构函数都可能抛出异常
#include <iostream>
#include <memory>

class Base {
public:
    virtual ~Base() {
        std::cout << "Base destructor" << std::endl;
        cleanup_base();
    }
    
    virtual void cleanup_base() {
        // 可能抛出异常
        throw std::runtime_error("Base cleanup failed");
    }
};

class Derived : public Base {
public:
    ~Derived() override {
        std::cout << "Derived destructor" << std::endl;
        cleanup_derived();
    }
    
    void cleanup_derived() {
        // 也可能抛出异常
        throw std::runtime_error("Derived cleanup failed");
    }
    
    void cleanup_base() override {
        // 重写基类清理
        std::cout << "Derived cleaning up base resources" << std::endl;
        // 仍然可能抛出异常
    }
};

int main() {
    try {
        Derived d;
        // d离开作用域时，会先调用~Derived()，再调用~Base()
        // 如果两者都抛出异常，程序终止
    } catch (const std::exception& e) {
        std::cout << "Caught: " << e.what() << std::endl;
    }
    return 0;
}

四、解决方案

4.1 基本原则：不在析构函数中抛出异常

4.1.1 使用noexcept确保安全
// ✅ 正确示例：使用noexcept确保析构函数安全
#include <iostream>
#include <fstream>

class SafeFile {
private:
    std::FILE* file_;
    
public:
    explicit SafeFile(const char* filename) 
        : file_(std::fopen(filename, "r")) {
        if (!file_) {
            throw std::runtime_error("Failed to open file");
        }
        std::cout << "File opened: " << filename << std::endl;
    }
    
    // 声明为noexcept，承诺不抛出异常
    ~SafeFile() noexcept {
        std::cout << "Closing file" << std::endl;
        if (file_) {
            // 即使失败也不抛出异常
            std::fclose(file_);
            // 可以记录日志，但不抛出
        }
    }
    
    // 禁止拷贝
    SafeFile(const SafeFile&) = delete;
    SafeFile& operator=(const SafeFile&) = delete;
    
    // 允许移动
    SafeFile(SafeFile&& other) noexcept 
        : file_(other.file_) {
        other.file_ = nullptr;
    }
    
    SafeFile& operator=(SafeFile&& other) noexcept {
        if (this != &other) {
            cleanup();
            file_ = other.file_;
            other.file_ = nullptr;
        }
        return *this;
    }
    
    void read_data() {
        // 使用文件...
    }
    
private:
    void cleanup() noexcept {
        if (file_) {
            std::fclose(file_);
            file_ = nullptr;
        }
    }
};

int main() {
    try {
        SafeFile file("data.txt");
        file.read_data();
        // 析构函数被调用，保证不抛出异常
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    return 0;
}
4.1.2 提供显式释放函数
// ✅ 正确示例：提供显式释放函数，析构函数作为后备
#include <iostream>
#include <memory>
#include <mutex>

class ThreadSafeResource {
private:
    std::unique_ptr<int[]> data_;
    std::mutex mutex_;
    bool released_;
    
public:
    ThreadSafeResource(size_t size) 
        : data_(std::make_unique<int[]>(size)), 
          released_(false) {
        std::cout << "Resource allocated" << std::endl;
    }
    
    // 显式释放函数，可以抛出异常
    void release() {
        std::lock_guard<std::mutex> lock(mutex_);
        
        if (released_) {
            return; // 已经释放
        }
        
        std::cout << "Releasing resource..." << std::endl;
        
        // 可能抛出异常的清理操作
        perform_complex_cleanup();
        
        data_.reset();
        released_ = true;
        std::cout << "Resource released successfully" << std::endl;
    }
    
    // 析构函数作为后备，不抛出异常
    ~ThreadSafeResource() noexcept {
        try {
            if (!released_) {
                std::cout << "Warning: Resource not explicitly released, "
                          << "performing emergency cleanup" << std::endl;
                
                std::lock_guard<std::mutex> lock(mutex_);
                if (!released_) {
                    // 执行简单的、不会抛出异常的清理
                    data_.reset();
                    released_ = true;
                }
            }
        } catch (...) {
            // 捕获所有异常，防止传播
            std::cerr << "ERROR: Unexpected exception in destructor" << std::endl;
            // 记录日志，但不重新抛出
        }
    }
    
    // 使用资源
    void process() {
        std::lock_guard<std::mutex> lock(mutex_);
        if (released_) {
            throw std::runtime_error("Resource already released");
        }
        // 处理数据...
    }
    
private:
    void perform_complex_cleanup() {
        // 复杂的清理逻辑，可能失败
        // 但可以抛出异常，因为不是在析构函数中
        if (data_) {
            // 模拟可能失败的操作
            bool cleanup_failed = false; // 模拟变量
            
            if (cleanup_failed) {
                throw std::runtime_error("Complex cleanup failed");
            }
        }
    }
};

int main() {
    try {
        ThreadSafeResource resource(1024);
        
        resource.process();
        
        // 显式释放，可以处理异常
        resource.release();
        
    } catch (const std::exception& e) {
        std::cerr << "Error during operation: " << e.what() << std::endl;
        // 即使release()抛出异常，析构函数仍会安全清理
    }
    
    return 0;
}

4.2 异常安全的资源管理

4.2.1 RAII模式与异常安全
// ✅ 正确示例：异常安全的RAII包装器
#include <iostream>
#include <memory>
#include <functional>
#include <vector>

// 通用RAII包装器
template<typename Resource, typename Cleanup>
class ScopedResource {
private:
    Resource resource_;
    Cleanup cleanup_;
    bool released_;
    
public:
    // 构造函数可能抛出异常
    template<typename... Args>
    ScopedResource(Cleanup cleanup, Args&&... args) 
        : resource_(std::forward<Args>(args)...), 
          cleanup_(std::move(cleanup)), 
          released_(false) {
    }
    
    // 移动构造
    ScopedResource(ScopedResource&& other) noexcept
        : resource_(std::move(other.resource_)),
          cleanup_(std::move(other.cleanup_)),
          released_(other.released_) {
        other.released_ = true;
    }
    
    // 析构函数不抛出异常
    ~ScopedResource() noexcept {
        if (!released_) {
            try {
                cleanup_(resource_);
            } catch (...) {
                // 记录错误但不抛出
                std::cerr << "WARNING: Cleanup threw exception, ignoring" << std::endl;
            }
        }
    }
    
    // 显式释放
    void release() {
        if (!released_) {
            cleanup_(resource_);
            released_ = true;
        }
    }
    
    // 获取资源
    Resource& get() { return resource_; }
    const Resource& get() const { return resource_; }
    
    // 禁止拷贝
    ScopedResource(const ScopedResource&) = delete;
    ScopedResource& operator=(const ScopedResource&) = delete;
};

// 使用示例
void demo_scoped_resource() {
    // 示例1：文件句柄
    auto file_cleanup = [](FILE* f) {
        if (f && f != stdin && f != stdout && f != stderr) {
            std::cout << "Closing file" << std::endl;
            if (std::fclose(f) != 0) {
                // 记录错误但不抛出
                std::cerr << "Failed to close file" << std::endl;
            }
        }
    };
    
    {
        ScopedResource<FILE*, decltype(file_cleanup)> 
            file(file_cleanup, std::fopen("test.txt", "w"));
        
        if (file.get()) {
            std::fprintf(file.get(), "Hello World\n");
        }
        // 文件自动关闭，即使抛出异常
    }
    
    // 示例2：内存分配
    auto memory_cleanup = [](int* ptr) {
        std::cout << "Freeing memory" << std::endl;
        delete[] ptr;
    };
    
    ScopedResource<int*, decltype(memory_cleanup)> 
        memory(memory_cleanup, new int[100]);
    
    // 使用内存...
    memory.get()[0] = 42;
}
4.2.2 使用std::unique_ptr自定义删除器
// ✅ 正确示例：使用unique_ptr自定义删除器
#include <iostream>
#include <memory>
#include <vector>

// 自定义删除器，保证不抛出异常
struct SafeFileDeleter {
    void operator()(FILE* f) const noexcept {
        if (f && f != stdin && f != stdout && f != stderr) {
            std::cout << "Deleter closing file" << std::endl;
            // 忽略错误，保证不抛出
            std::fclose(f);
        }
    }
};

using SafeFilePtr = std::unique_ptr<FILE, SafeFileDeleter>;

// 复杂资源的自定义删除器
class DatabaseConnection {
public:
    static DatabaseConnection* connect(const std::string& url) {
        std::cout << "Connecting to database: " << url << std::endl;
        return new DatabaseConnection();
    }
    
    void disconnect() {
        std::cout << "Disconnecting database" << std::endl;
        // 可能抛出异常的操作
        throw std::runtime_error("Disconnection failed");
    }
    
    void query(const std::string& sql) {
        std::cout << "Executing: " << sql << std::endl;
    }
};

struct SafeDatabaseDeleter {
    void operator()(DatabaseConnection* db) const noexcept {
        if (db) {
            try {
                db->disconnect();  // 可能抛出异常
            } catch (const std::exception& e) {
                // 记录但不传播异常
                std::cerr << "Database disconnection error: " 
                          << e.what() << std::endl;
            } catch (...) {
                std::cerr << "Unknown database disconnection error" << std::endl;
            }
            delete db;
        }
    }
};

using SafeDatabasePtr = std::unique_ptr<DatabaseConnection, SafeDatabaseDeleter>;

int main() {
    // 文件示例
    SafeFilePtr file(std::fopen("data.txt", "w"));
    if (file) {
        std::fprintf(file.get(), "Test data\n");
    }
    
    // 数据库示例
    try {
        SafeDatabasePtr db(DatabaseConnection::connect("localhost/test"));
        db->query("SELECT * FROM users");
        
        // 即使后面抛出异常，删除器也会安全清理
        throw std::runtime_error("Simulated error");
        
    } catch (const std::exception& e) {
        std::cout << "Caught: " << e.what() << std::endl;
        // db的删除器会被调用，不会导致程序终止
    }
    
    return 0;
}

4.3 处理多重资源清理

4.3.1 资源收集器模式
// ✅ 正确示例：资源收集器模式
#include <iostream>
#include <vector>
#include <functional>
#include <memory>

class ResourceCollector {
private:
    std::vector<std::function<void()>> cleanup_actions_;
    bool committed_;
    
public:
    ResourceCollector() : committed_(false) {}
    
    ~ResourceCollector() noexcept {
        rollback();
    }
    
    // 添加清理动作
    template<typename Fn>
    void add_cleanup(Fn&& cleanup) {
        cleanup_actions_.emplace_back(std::forward<Fn>(cleanup));
    }
    
    // 提交所有资源（不执行清理）
    void commit() noexcept {
        committed_ = true;
        cleanup_actions_.clear();
    }
    
    // 回滚（执行所有清理）
    void rollback() noexcept {
        if (committed_) {
            return;
        }
        
        // 逆序执行清理（LIFO）
        for (auto it = cleanup_actions_.rbegin(); 
             it != cleanup_actions_.rend(); ++it) {
            try {
                (*it)();
            } catch (const std::exception& e) {
                std::cerr << "Cleanup error (ignored): " << e.what() << std::endl;
            } catch (...) {
                std::cerr << "Unknown cleanup error (ignored)" << std::endl;
            }
        }
        
        cleanup_actions_.clear();
        committed_ = true;
    }
};

// 使用示例
class TransactionalFile {
private:
    FILE* file_;
    ResourceCollector& collector_;
    
public:
    TransactionalFile(const char* filename, 
                     ResourceCollector& collector)
        : collector_(collector) {
        
        file_ = std::fopen(filename, "w");
        if (!file_) {
            throw std::runtime_error("Failed to open file");
        }
        
        // 注册清理动作
        collector_.add_cleanup([this]() {
            if (file_) {
                std::cout << "Rollback: closing file" << std::endl;
                std::fclose(file_);
                file_ = nullptr;
            }
        });
    }
    
    ~TransactionalFile() {
        // 析构函数不做清理，由ResourceCollector管理
    }
    
    void write(const char* data) {
        if (!file_) {
            throw std::runtime_error("File not open");
        }
        std::fprintf(file_, "%s", data);
    }
};

void perform_transaction() {
    ResourceCollector collector;
    
    try {
        TransactionalFile file1("file1.txt", collector);
        TransactionalFile file2("file2.txt", collector);
        
        file1.write("Data for file1\n");
        file2.write("Data for file2\n");
        
        // 模拟错误
        throw std::runtime_error("Transaction failed");
        
        // 如果成功到达这里
        collector.commit();
        std::cout << "Transaction committed" << std::endl;
        
    } catch (const std::exception& e) {
        std::cerr << "Transaction error: " << e.what() << std::endl;
        // collector的析构函数会自动回滚
        // 或者可以显式调用：collector.rollback();
    }
    
    // 离开作用域时，如果未提交，collector会回滚
}

int main() {
    perform_transaction();
    return 0;
}

4.4 处理继承体系中的析构函数

4.4.1 虚析构函数的异常安全
// ✅ 正确示例：安全的虚析构函数实现
#include <iostream>
#include <memory>
#include <mutex>

class Base {
public:
    virtual ~Base() noexcept {
        // 基类析构函数必须处理异常安全
        try {
            cleanup();
        } catch (...) {
            handle_destructor_exception();
        }
    }
    
    // 显式释放函数
    virtual void release() {
        cleanup();
    }
    
protected:
    virtual void cleanup() {
        // 基类清理逻辑
        std::cout << "Base cleanup" << std::endl;
    }
    
private:
    void handle_destructor_exception() noexcept {
        // 记录错误，保证不抛出
        std::cerr << "CRITICAL: Exception in base destructor" << std::endl;
        // 可能的紧急清理
    }
};

class Derived : public Base {
protected:
    void cleanup() override {
        // 先清理派生类资源
        cleanup_derived();
        // 再调用基类清理
        Base::cleanup();
    }
    
private:
    void cleanup_derived() {
        std::cout << "Derived cleanup" << std::endl;
        // 可能抛出异常的操作
        bool should_throw = false; // 示例
        
        if (should_throw) {
            throw std::runtime_error("Derived cleanup failed");
        }
    }
};

class SafeDerived : public Base {
public:
    // 更安全的做法：覆盖release而不是cleanup
    void release() override {
        try {
            cleanup_safe();
            Base::release();
        } catch (const std::exception& e) {
            std::cerr << "Error in SafeDerived::release: " 
                      << e.what() << std::endl;
            throw; // 可以在release中抛出
        }
    }
    
private:
    void cleanup_safe() {
        std::cout << "SafeDerived cleanup" << std::endl;
        // 清理逻辑
    }
    
    // 覆盖cleanup但要保证不抛出
    void cleanup() noexcept override {
        try {
            cleanup_safe();
        } catch (...) {
            std::cerr << "Suppressed exception in SafeDerived::cleanup" 
                      << std::endl;
        }
    }
};

int main() {
    try {
        std::unique_ptr<Base> obj = std::make_unique<Derived>();
        
        // 最好显式释放
        obj->release();
        
    } catch (const std::exception& e) {
        std::cerr << "Caught: " << e.what() << std::endl;
    }
    
    // 即使不调用release，析构函数也是安全的
    {
        std::unique_ptr<Base> obj = std::make_unique<SafeDerived>();
        // 离开作用域时，析构函数不会抛出异常
    }
    
    return 0;
}

五、高级技巧和最佳实践

5.1 使用std::uncaught_exceptions()检测异常状态

// ✅ 正确示例：使用C++17的std::uncaught_exceptions()
#include <iostream>
#include <exception>

class SmartResource {
public:
    SmartResource() {
        std::cout << "SmartResource created" << std::endl;
    }
    
    ~SmartResource() {
        int uncaught = std::uncaught_exceptions();
        
        std::cout << "Destructor called with "
                  << uncaught << " uncaught exceptions" << std::endl;
        
        if (uncaught > 0) {
            // 有异常正在传播，进行最小化安全清理
            emergency_cleanup();
        } else {
            // 正常清理，可以进行复杂操作
            normal_cleanup();
        }
    }
    
    void use() {
        std::cout << "Using resource" << std::endl;
    }
    
private:
    void emergency_cleanup() noexcept {
        std::cout << "Performing emergency cleanup" << std::endl;
        // 只做不会抛出异常的操作
    }
    
    void normal_cleanup() {
        std::cout << "Performing normal cleanup" << std::endl;
        try {
            // 可能抛出异常的复杂清理
            if (should_fail()) {
                throw std::runtime_error("Normal cleanup failed");
            }
        } catch (const std::exception& e) {
            std::cerr << "Cleanup failed: " << e.what() << std::endl;
            // 记录但不重新抛出
        }
    }
    
    bool should_fail() { return false; } // 示例
};

void test_exception_state() {
    try {
        SmartResource res;
        res.use();
        throw std::runtime_error("Test exception");
    } catch (const std::exception& e) {
        std::cout << "Caught: " << e.what() << std::endl;
    }
}

int main() {
    test_exception_state();
    return 0;
}

5.2 双重保险模式

// ✅ 正确示例：双重保险模式
#include <iostream>
#include <memory>
#include <mutex>

class DoubleSafetyResource {
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
    
public:
    DoubleSafetyResource();
    ~DoubleSafetyResource() noexcept;
    
    // 显式关闭，可能抛出异常
    void close();
    
    // 使用资源
    void use();
    
private:
    void safe_cleanup() noexcept;
};

struct DoubleSafetyResource::Impl {
    FILE* file = nullptr;
    bool closed = false;
    std::mutex mutex;
    
    ~Impl() noexcept {
        safe_close();
    }
    
    void safe_close() noexcept {
        std::lock_guard<std::mutex> lock(mutex);
        if (file && !closed) {
            std::fclose(file);
            file = nullptr;
            closed = true;
        }
    }
    
    void close_with_checks() {
        std::lock_guard<std::mutex> lock(mutex);
        if (closed) {
            throw std::runtime_error("Already closed");
        }
        
        if (file) {
            // 复杂的关闭逻辑
            if (std::fclose(file) != 0) {
                throw std::runtime_error("Failed to close file");
            }
            file = nullptr;
            closed = true;
        }
    }
};

DoubleSafetyResource::DoubleSafetyResource() 
    : impl_(std::make_unique<Impl>()) {
    impl_->file = std::fopen("data.bin", "wb");
    if (!impl_->file) {
        throw std::runtime_error("Failed to open file");
    }
}

DoubleSafetyResource::~DoubleSafetyResource() noexcept {
    safe_cleanup();
}

void DoubleSafetyResource::safe_cleanup() noexcept {
    if (impl_) {
        impl_->safe_close();
    }
}

void DoubleSafetyResource::close() {
    if (impl_) {
        impl_->close_with_checks();
    }
}

void DoubleSafetyResource::use() {
    if (!impl_ || impl_->closed) {
        throw std::runtime_error("Resource not available");
    }
    // 使用资源
}

int main() {
    try {
        DoubleSafetyResource resource;
        
        resource.use();
        
        // 首选：显式关闭，可以处理异常
        resource.close();
        
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        // 析构函数仍会安全清理
    }
    
    return 0;
}

5.3 单元测试策略

// ✅ 正确示例：测试析构函数的异常安全性
#include <iostream>
#include <cassert>
#include <stdexcept>
#include <csignal>
#include <cstdlib>

// 测试辅助工具
class DestructorTestHarness {
    static bool terminate_called;
    
public:
    static void setup() {
        std::set_terminate([]() {
            terminate_called = true;
            std::cerr << "std::terminate called as expected" << std::endl;
            std::exit(0); // 正常退出测试
        });
    }
    
    static bool was_terminate_called() {
        return terminate_called;
    }
    
    static void reset() {
        terminate_called = false;
    }
};

bool DestructorTestHarness::terminate_called = false;

// 被测试的类
class TestClass {
public:
    enum class Mode {
        Safe,
        Throwing,
        DoubleThrow
    };
    
    static int instance_count;
    
    TestClass(Mode mode = Mode::Safe) : mode_(mode) {
        ++instance_count;
    }
    
    ~TestClass() noexcept(false) {
        --instance_count;
        
        switch (mode_) {
            case Mode::Safe:
                // 安全，不抛出
                break;
            case Mode::Throwing:
                throw std::runtime_error("TestClass destructor threw");
                break;
            case Mode::DoubleThrow:
                if (std::uncaught_exceptions() > 0) {
                    // 已经有异常在传播，再抛出一个会导致terminate
                    throw std::logic_error("Second exception during stack unwind");
                }
                break;
        }
    }
    
private:
    Mode mode_;
};

int TestClass::instance_count = 0;

// 测试用例
void test_safe_destructor() {
    std::cout << "Testing safe destructor..." << std::endl;
    DestructorTestHarness::reset();
    
    {
        TestClass obj(TestClass::Mode::Safe);
        assert(TestClass::instance_count == 1);
    }
    
    assert(TestClass::instance_count == 0);
    assert(!DestructorTestHarness::was_terminate_called());
    std::cout << "PASS" << std::endl;
}

void test_throwing_destructor_no_exception() {
    std::cout << "Testing throwing destructor (no active exception)..." << std::endl;
    DestructorTestHarness::reset();
    
    try {
        TestClass obj(TestClass::Mode::Throwing);
        // obj离开作用域，析构函数抛出异常
    } catch (const std::exception& e) {
        std::cout << "Caught: " << e.what() << std::endl;
        assert(TestClass::instance_count == 0);
        assert(!DestructorTestHarness::was_terminate_called());
        std::cout << "PASS" << std::endl;
        return;
    }
    
    assert(false && "Should have caught exception");
}

void test_double_throwing_destructor() {
    std::cout << "Testing double-throwing destructor..." << std::endl;
    DestructorTestHarness::reset();
    
    try {
        TestClass inner(TestClass::Mode::DoubleThrow);
        throw std::runtime_error("First exception");
    } catch (...) {
        // 内层对象在栈展开时析构，会抛出第二个异常
        // 这应该导致terminate
    }
    
    // 如果到达这里，测试失败
    assert(false && "Should have terminated");
}

int main() {
    DestructorTestHarness::setup();
    
    try {
        test_safe_destructor();
        test_throwing_destructor_no_exception();
        
        // 这个测试会导致terminate，所以单独运行
        // test_double_throwing_destructor();
        
        std::cout << "\nAll tests passed!" << std::endl;
        return 0;
        
    } catch (const std::exception& e) {
        std::cerr << "Test failed: " << e.what() << std::endl;
        return 1;
    }
}

六、总结和最佳实践

6.1 核心原则

  1. 绝不从析构函数中抛出异常
  2. 析构函数应声明为noexcept
  3. 使用RAII模式管理资源
  4. 提供显式释放函数处理可能失败的操作

6.2 设计模式

模式适用场景优点
显式释放函数需要处理可能失败的清理操作可以抛出异常，更好的错误处理
双重保险关键资源，必须保证清理即使显式释放失败，析构函数也能安全清理
资源收集器事务性操作，需要原子性支持提交/回滚语义
智能指针+自定义删除器通用资源管理自动生命周期管理

6.3 代码检查清单

// 析构函数设计检查清单
class YourClass {
public:
    // ✅ 正确做法
    ~YourClass() noexcept {           // 1. 添加noexcept
        try {
            cleanup();                // 2. 在try块中清理
        } catch (...) {
            // 3. 记录错误但不传播
            log_error("Destructor cleanup failed");
            // 4. 执行紧急清理（如果需要）
            emergency_cleanup();
        }
    }
    
    // ✅ 提供显式释放函数
    void release() {
        // 可以抛出异常
        complex_cleanup();
        released_ = true;
    }
    
private:
    void cleanup() noexcept {        // 5. 清理函数也声明noexcept
        if (!released_) {
            simple_cleanup();         // 6. 只做简单、安全的操作
        }
    }
    
    void complex_cleanup() {
        // 复杂逻辑，可能失败
    }
    
    void simple_cleanup() noexcept {
        // 简单逻辑，保证不失败
    }
    
    void emergency_cleanup() noexcept {
        // 最后的安全网
    }
    
    bool released_ = false;
};

6.4 现代C++特性

// C++17/20最佳实践
class ModernResource {
public:
    ModernResource() {
        // 获取资源
    }
    
    ~ModernResource() {
        // 使用if constexpr或concepts进行条件清理
        if constexpr (has_safe_cleanup_v<ResourceType>) {
            resource_.cleanup_safe();
        } else {
            // 后备方案
        }
    }
    
    // C++20概念约束的显式释放
    template<typename T>
    requires std::is_invocable_v<T, Resource&>
    void release_with(T&& cleanup_fn) {
        cleanup_fn(resource_);
        released_ = true;
    }
    
private:
    Resource resource_;
    bool released_ = false;
};

记住：析构函数中的异常就像是飞机降落时引擎失效——你无法安全地处理它，所以必须首先防止它发生。

C++ 中析构函数的详解
m0_73640344的博客
12-25 645
析构函数（Destructor）是一个特殊的成员函数，在对象生命周期结束时自动调用，用于执行清理工作。与构造函数相对应，析构函数的主要任务是释放对象在生命周期内分配的资源，如动态内存、文件句柄、网络连接等。析构函数是 C++ 中管理资源的关键机制，负责在对象生命周期结束时自动执行清理工作。通过正确地定义和使用析构函数，开发者可以有效避免内存泄漏和资源泄漏，提升程序的稳定性和安全性。在面向对象设计中，理解并运用好析构函数，对于实现健壮和高效的代码至关重要。
详解构造和析构函数是否可以抛出异常
2301_77156905的博客
12-02 1707
本文将详细探讨构造函数和析构函数中抛出异常的问题，并提供最佳实践建议。
C++虚析构函数详解：从基础到实践
行知SLAM
09-23 520
本文系统介绍了C++虚析构函数的概念、语法特性及其重要性。重点解释了虚析构函数确保基类指针删除派生类对象时能正确调用派生类析构函数的机制，以及= default语法生成高效默认实现的优势。通过代码示例分析了virtual ~LocalizationApplication() = default;在机器人系统中的实际应用，总结了虚析构函数的最佳实践和使用场景，特别强调了在继承体系和多态场景中的必要性，帮助开发者避免资源泄漏问题，提升代码质量。
c++ 析构函数详解
HJQD777的博客
09-07 530
定义：当类需要释放动态分配的资源时，需要定义一个自定义析构函数。public:// 动态内存分配// 释放动态内存private:int* data;析构函数：在对象生命周期结束时自动调用，用于清理和释放资源。默认析构函数：如果未显式定义，编译器会生成一个。自定义析构函数：当对象需要清理动态分配的资源时定义。虚析构函数：用于支持多态，确保正确清理派生类资源。注意事项：析构函数应避免抛出异常，并且在析构过程中要小心成员对象的析构顺序。
【C++】拷贝构造函数，析构函数详解！
luhaoran814的博客
11-23 2934
内置类型系统会默认生成拷贝构造进行值拷贝，对自定义类型调用它的拷贝构造。类中如果没有涉及资源申请时（例如 new申请空间），拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。拷贝构造也是构造，是拷贝构造的一个重载。
C++析构函数详解与实战源码解析
weixin_32251525的博客
09-08 255
在C++中，析构函数是类的一个特殊成员函数，用于在对象生命周期结束时执行清理操作。它不仅承担着资源释放的任务，还对程序的健壮性和可维护性有着深远影响。本章将深入剖析析构函数的定义规则、调用时机及其与构造函数的调用顺序关系，帮助读者全面理解其工作机制。析构函数的命名规则非常明确：类名前加一个波浪线，并且没有返回值、没有参数。这一特性使得析构函数在整个类中只能存在一个版本，不能重载。
36、C++ 数据结构与构造析构函数详解
pluto的博客
11-13 6
本文详细讲解了C++中的数据结构与构造析构函数的核心概念，涵盖数据类型转换、结构体与类的区别及使用、命名空间的作用、构造函数与析构函数的定义与调用顺序，并深入探讨了构造函数重载、成员初始化、默认与复制构造函数、虚析构函数等关键知识点。通过丰富示例代码和流程图，帮助读者全面掌握C++对象的生命周期管理与资源释放机制，提升编程规范与效率。
【面向对象】构造函数与析构函数详解
qq_43840665的博客
02-01 2264
构造函数与析构函数详解。
C++构造和折构函数详解，超详细！
PingdiGuo_guo的博客
10-18 2366
C++构造和折构函数的利弊，操作，作用，特点，思想，练习喔~~，关注主播不迷路耶！
C++析构函数详解及其在资源管理中的应用
C++析构函数是面向对象编程中极为关键的一个组成部分，其主要作用是在对象生命周期结束时自动执行清理工作，确保程序不会出现资源泄露、内存泄漏或文件句柄未关闭等问题。在C++中，每一个类都可以定义一个析构函数，...
C++析构函数详解及其在内存管理中的应用
本文围绕“C++析构函数详解”这一主题，深入剖析其定义、语法结构、调用时机、使用规则以及在实际编程中的典型应用场景，并结合描述中提到的Person类示例进行系统性阐述，帮助开发者全面掌握析构函数的核心原理与...
C++构造与析构函数详解：默认、拷贝、移动及委托构造的应用与优化
析构函数的实现必须保证异常安全，通常建议在析构函数中避免抛出异常，以防止程序在析构过程中崩溃。 在**综合示例**部分，文章通过一个完整的类设计演示了如何合理使用上述构造函数和析构函数。例如，一个资源管理...
Java与KOK中的构造与析构函数详解
从给定的标题“Java KOK 构造与析构函数”以及描述、标签和压缩包中所列的子文件名称，我们可以提取出一系列与Java面向对象编程相关的核心知识点。以下是对这些知识点的详细阐述。 首先，标题中提到的“构造与析构...
[C++]string类的使用和模拟实现
我的博客
12-01 886
本文系统介绍了C++中string类的使用与实现方法。首先分析了string类的函数风格，包括参数传递方式、const与非const迭代器区别及隐式类型转换特性。然后详细讲解了string类的核心实现，包括构造函数、析构函数、拷贝构造等基础功能，以及迭代器、容量操作等内联函数实现。重点剖析了字符串的增删查改操作，如扩容机制、插入删除算法等实现细节，并指出了常见错误点（如'\0'处理、size_t循环问题）。通过具体代码示例展示了operator>>、insert等关键函数的实现逻辑，帮助读者掌握
c++——探讨a÷b（long long)
12-02 290
见正文
C语言 函数
cja0222的博客
12-01 921
在C语言的世界里，函数不仅是代码组织的基本单元，更是程序员构建复杂系统的思维工具。从简单的 main()函数到庞大的库函数集合，函数贯穿了C语言的每个角落。重要的是自定义函数。自定义函数和库函数一样，有函数名，返回值类型和函数参数。所谓自定义就是这些都是我们自己来设计。这给我们自己一个很大的发挥空间。ret_type fun_name(形式参数)//ret_type是函数返回类型//fun_name是函数名// ()括号中放的是形式参数//{}括起来的是函数体。
C++ 设计模式之单例模式详细介绍
XiaoBinbest的博客
12-01 1472
唯一性：类的实例在整个程序中只能有一个，禁止外部通过new、拷贝等方式创建多个实例。全局访问：提供一个静态方法（如），让程序任何地方都能便捷访问该实例。可控初始化：根据需求选择“提前初始化”（饿汉式）或“延迟初始化”（懒汉式），平衡资源占用与启动速度。实现方式线程安全（C++11+）延迟初始化代码复杂度内存泄漏风险推荐优先级Meyers 单例（局部静态）是是极低无★★★★★饿汉式（全局静态）是否低无★★★★☆懒汉式（互斥锁）是是中有（需手动销毁）
LinuxC语言并发程序笔记补充
chenzhou__的博客
12-04 626
锁除了互斥锁，还有一个读写锁，进程通信还有对互斥锁优化的条件变量和死锁的概念。
单片机 使用 cJson 添加 无符号 32 位数值（uint32_t）溢出问题的解决办法
最新发布
weixin_46158019的博客
12-05 378
的最大值（2147483647）时，数据不正常。，使用的是 ARMCC 系统工具链 ，文件。单片机 使用在 cJSON 中添加无符号32位（）数据出现「溢出」。）数据 ，超过 有符号32位(，查看此函数 调用关系 —>cJson 使用的函数是。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值