检测原始指针的错误删除：析构函数抛异常是否合理？

我深知从析构函数抛出异常几乎被公认为是一种糟糕的做法。但我遇到这样的场景：某类对象仅由std::unique_ptr管理生命周期，却需将其原始指针传给遗留代码或第三方库。若临时持有该原始指针的代码尝试删除对象，我希望立即发现问题；否则当std::unique_ptr销毁时会二次删除对象导致崩溃，且难以定位首次删除的位置。我希望崩溃发生在首次删除时，以便排查问题。

以下是我想到的解决方案：

#include <iostream>
#include <memory>

class managedLifetime
{
public:
    managedLifetime() { }
    
    virtual ~managedLifetime()
    {
        throw()
    }
};

class managedLifetimeCustomDeleter
{
public:
    // Delete the object, safely catching the exception 
    void operator()(managedLifetime * ml) const
    {
        try
        {
            delete ml;
        }
        catch
        {
        }
    }
};

void hazard(managedLifetime * object)
{
    // I want this to crash
    delete object;
}

int main()
{
    std::unique_ptr<managedLifetime, managedLifetimeCustomDeleter> obj( new managedLifetime() );
    
    hazard(obj.get());

    std::cout << "I want the application to crash before I get to here" << std::endl;
}

当前代码会在输出文本后崩溃，但我希望崩溃发生在输出前，以便定位问题。请问这是否属于析构函数抛出异常的合理场景？或是有更简单安全的实现方案？

关于场景合理性 #

你的需求确实是析构函数抛异常的边缘合理场景，但你的原始实现存在关键错误：throw()是已弃用的动态异常规范，它表示析构函数不会抛出任何异常，这完全违背了你想要触发异常的初衷，也是代码没有在delete object时立即崩溃的原因。

不过，即使修正这个错误，析构函数抛异常依然存在潜在风险（比如对象被意外在栈上创建时，析构抛异常会导致未定义行为），因此更推荐用更直接安全的方案。

更简单安全的实现方案 #

方案一：标记位+主动崩溃（优先推荐）

通过一个标记位追踪对象是否由unique_ptr的自定义删除器处理，非法删除时直接调用abort()终止程序，确保问题立即暴露：

#include <iostream>
#include <memory>
#include <cstdlib> // 用于abort()

class managedLifetime
{
private:
    mutable bool is_owned_by_unique_ptr = false;
public:
    managedLifetime() = default;
    
    ~managedLifetime()
    {
        if (!is_owned_by_unique_ptr) {
            std::cerr << "错误：对象被unique_ptr以外的代码非法删除！" << std::endl;
            abort(); // 立即崩溃，终止程序
        }
    }

    // 让自定义删除器可以修改标记位
    friend class managedLifetimeCustomDeleter;
};

class managedLifetimeCustomDeleter
{
public:
    void operator()(managedLifetime * ml) const
    {
        ml->is_owned_by_unique_ptr = true;
        delete ml;
    }
};

void hazard(managedLifetime * object)
{
    delete object; // 这里会直接触发abort()，程序在输出前崩溃
}

int main()
{
    std::unique_ptr<managedLifetime, managedLifetimeCustomDeleter> obj(new managedLifetime());
    
    hazard(obj.get());

    std::cout << "这行代码永远不会被执行" << std::endl;
}

这个方案的优势：

• 行为明确，非法删除时立即终止，不会有异常传播的不确定性
• 完全避免了析构函数抛异常带来的潜在风险
• 崩溃时的错误信息可以帮助快速定位问题

方案二：修正异常实现（不推荐）

如果坚持用异常思路，需要显式允许析构函数抛异常，并在自定义删除器中绕过异常逻辑：

#include <iostream>
#include <memory>
#include <stdexcept>

class managedLifetime
{
public:
    managedLifetime() = default;
    
    ~managedLifetime() noexcept(false) // 显式声明析构函数可以抛出异常
    {
        throw std::runtime_error("对象被unique_ptr以外的代码非法删除！");
    }
};

class managedLifetimeCustomDeleter
{
public:
    void operator()(managedLifetime * ml) const
    {
        ml->~managedLifetime(); // 手动调用析构（此时不会触发异常，因为我们后续手动释放内存）
        operator delete(ml);    // 直接释放内存，跳过delete调用的完整析构流程
    }
};

void hazard(managedLifetime * object)
{
    delete object; // 这里会抛出异常，未捕获则程序立即终止
}

int main()
{
    std::unique_ptr<managedLifetime, managedLifetimeCustomDeleter> obj(new managedLifetime());
    
    hazard(obj.get());

    std::cout << "这行代码永远不会被执行" << std::endl;
}

注意：此方案仍有风险，若对象被意外创建在栈上，析构时抛异常会导致未定义行为，因此不推荐作为首选。

内容的提问来源于stack exchange，提问作者Eos Pengwern