我正在尝试编写一个单元测试来检测对我的类的 lock() 功能的无效使用。为此，我想使用析构函数并从那里抛出异常。不幸的是，g++ 没有捕获异常，而是决定调用 std::terminate()。

类有一个非常简化的版本:

class A
{
public:
    A() : f_lock(0) {}
    ~A() { if(f_lock) throw my_exception("still locked"); }
    lock() { ++f_lock; }
    unlock() { --f_lock; }
private:
    int f_lock;
};

有一个有效的测试:

A *a = new A;
a->lock();
...
a->unlock();
delete a;

我正在尝试编写无效测试:

A *a = new A;
a->lock();
...
bool success = false;
try
{
    delete a;
}
catch(my_exception const&)
{
    success = true;
}
catch(...)
{
    // anything else is a failure
}
if(!success)
{
    // test failed...
    CPPUNIT_ASSERT(!"test failed");
}

现在，delete 调用 std::terminate()，即使在另一个异常处于事件状态时未调用 throw。 (即 std::uncaught_exception() 为 false。)而且我显然捕获了所有异常!

是我做错了什么，还是 g++ 总是在析构函数中做错事？

更新:

dyp 在下面评论中的回答有效!以下不直接调用 std::terminate():

    ~A() noexcept(false) { throw ...; }

还有关于为什么你不想在析构函数中抛出的引用，这个页面非常好；

https://www.securecoding.cert.org/confluence/display/cplusplus/ERR33-CPP.+Destructors+must+not+throw+exceptions

为了澄清，这里有完整版的析构函数。正如我们所看到的，我首先发布了一条消息(它通常会出现在您的控制台中，也可能会出现在日志中)。其次，我确保我们还没有管理异常。最后，我抛出一个名为 exception_exit 的异常，预计会强制执行 terminate()，尽管在​​ GUI 应用程序中您可能想要显示一个 MessageBox某种方式让用户知道发生了什么事(因为您可以捕获消息，您可以将其显示给用户)然后强制关闭应用程序。

Node::~Node() noexcept(false)
{
    if(f_lock > 0)
    {
        // Argh! A throw in a destructor... Yet this is a fatal
        // error and it should never ever happen except in our
        // unit tests to verify that it does catch such a bug
        Message msg(message_level_t::MESSAGE_LEVEL_FATAL, err_code_t::AS_ERR_NOT_ALLOWED);
        msg << "a node got deleted while still locked.";

        // for security reasons, we do not try to throw another
        // exception if the system is already trying to process
        // an existing exception
        if(std::uncaught_exception())
        {
            // still we cannot continue...
            std::abort();
        }

        throw exception_exit(1, "a node got deleted while still locked.");
    }
}

还有一个细节，你应该使用NodeLock对象来管理f_lock标志。这是异常安全的，因为它使用 RAII(即作用域锁)。但是，此时我不想强制用户使用 NodeLock 来锁定/解锁节点，因此在析构函数中进行了此测试。

最佳答案

在 C++11 中，添加了 noexcept 关键字。这可以用于函数异常规范:

• noexcept(true) 与 throw() 相同，即此函数 terminates if anything are throwed
• noexcept(false) 表示函数可能会抛出任何东西

对于大多数函数，它们没有异常规范，除非您给它们一个。没有异常规范 的函数可能会抛出任何东西。

虽然在 C++11 [class.dtor]/3 中发现了析构函数的特殊情况:

A declaration of a destructor that does not have an exception-specification is implicitly considered to have the same exception-specification as an implicit declaration (15.4).

引用的规则 15.4 指出隐式声明的特殊成员函数总是有一个异常规范。规范由以下规则确定，[except.spec]/14:

An implicitly declared special member function (Clause 12) shall have an exception-specification. If f is an implicitly declared default constructor, copy constructor, move constructor, destructor, copy assignment operator, or move assignment operator, its implicit exception-specification specifies the type-id T if and only if T is allowed by the exception-specification of a function directly invoked by f’s implicit definition; f shall allow all exceptions if any function it directly invokes allows all exceptions, and f shall allow no exceptions if every function it directly invokes allows no exceptions.

本子句中的“它直接调用的函数”是指任何成员变量或基类的析构函数(递归应用)。如果没有这个函数，那么这个函数不允许有异常，所以默认是noexcept(true)。

我们可以这样总结上述引用中与您的代码相关的部分:

• 如果所有子对象都没有析构函数，或者隐式生成的析构函数，或者声明为 noexcept(true) 或等效的析构函数；那么这个类的析构函数默认为noexcept(true)。

因此，将析构函数更改为具有 noexcept(false) 将重现 C++03 的行为。

在 C++03 中，这些都没有出现，您的析构函数将默认允许所有异常。我不确定为什么要在 C++11 中进行此更改，但这可能是因为除非您真的知道自己在做什么，否则从析构函数中抛出是个坏主意。

关于c++ - 为什么在我的析构函数中抛出时总是得到 "terminate called after throwing an instance of..."？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26331364/