1

我一直在使用 C++ 中的异常处理和析构函数异常来更好地理解它，并且我遇到了一些我无法解释的奇怪行为（我希望这里有人可以帮助我）。

我写了这个简单的代码。这是一个异常类（Foo），在被破坏时会抛出自己。这里的目的是让异常从抛出的任何地方传播到 main()，在那里我明确地捕获它并阻止它重新抛出自己。

#include <iostream>

class Foo
{
public:
    Foo();

    virtual ~Foo();

    void stopThrowing() { keepThrowing_ = false; }

private:
    bool keepThrowing_;
};

Foo::Foo(): keepThrowing_(true)
{
    std::cout << "Foo created: " << this << std::endl;
}

Foo::~Foo()
{
    std::cout << "Foo destroyed: " << this << std::endl;

    if (keepThrowing_)
    {
        throw Foo();
    }
}

int main()
{
    try {
        try {
            throw Foo();
        } catch (const Foo&) {
            std::cout << "Foo caught" << std::endl;
        }
    } catch (Foo& ex) {
        std::cout << "Foo caught 2" << std::endl;
        ex.stopThrowing();
    } catch (...) {
        std::cout << "Unknown exception caught 2" << std::endl;
    }

    std::cout << "Done" << std::endl;

    return 0;
}

我知道这永远不应该在 C++ 中完成，但这不是重点——我试图理解 MSVC 中 x86 和 x64 异常处理之间的区别（我将在下一段中解释）。

当我使用 MSVC 为 x86 编译这段代码时（我主要使用 2010，但我也在 2005 年和 2012 年检查过），一切都很好，并且按预期工作：

Foo created: 001AFC1C
Foo caught
Foo destroyed: 001AFC1C
Foo created: 001AF31C
Foo caught 2
Foo destroyed: 001AF31C
Done

当我使用 MSVC 为 x64 编译此代码时，它严重失败：

Foo created: 000000000047F9B8
Foo caught
Foo destroyed: 000000000047F9B8
Foo created: 000000000047D310
Foo destroyed: 000000000047D310
Foo created: 000000000047C150
Foo destroyed: 000000000047C150
Foo created: 000000000047AF90
Foo destroyed: 000000000047AF90
Foo created: 0000000000479DD0
...

此时，它会不断创建和销毁 Foo 对象，直到达到堆栈溢出并崩溃。

如果我将析构函数更改为此片段（抛出一个 int 而不是 Foo）：

Foo::~Foo()
{
    std::cout << "Foo destroyed: " << this << std::endl;

    if (keepThrowing_)
    {
        throw 1;
    }
}

我收到以下输出：

Foo created: 00000000008EF858
Foo caught
Foo destroyed: 00000000008EF858

然后程序到达一个调试断言（std::terminate() 被调用），whenthrow 1;被执行。

我的问题是：这里发生了什么？看起来 x64 上的 MSVC 不批准这种行为，但感觉不对，因为它确实适用于 x86。我使用 MinGW 和 MinGW-w64 为 x86 和 x64 编译了这段代码，两个程序都按预期工作。这是 MSVC 中的错误吗？谁能想到绕过这个问题的方法，或者为什么微软决定阻止这种情况在 x64 上发生？

谢谢。

4

1 回答 1

2

我相信 32 位和 64 位不同的原因是 32 位版本使用复制省略，而 64 位版本没有。gcc我可以使用-fno-elide-constructors标志重现 64 位版本的结果。

在 64 位版本中发生的是任何throw Foo();行都会创建一个临时Foo对象，然后将其复制到存储异常值的任何位置。Foo然后销毁临时文件，这会导致throw Foo();执行另一行，从而创建另一个被复制和销毁的临时文件，依此类推。如果您添加带有打印语句的复制构造函数，您应该会看到它在 64 位版本中被重复调用，而在 32 位版本中根本没有被调用。

至于为什么您的throw 1版本调用std::terminate，这是因为如果在析构函数中抛出异常而另一个异常仍在传播，则会std::terminate被调用，因为无法同时处理两个异常。所以你首先throw Foo()在 main 中，然后当临时对象Foo被销毁时，它会抛出1它的析构函数，但是Foo已经处理了一个异常，所以程序只是放弃并抛出了std::terminate。

现在您可能想知道为什么在使用throw Foo();. 这是因为没有复制省略，实际上永远不会抛出异常Foo::~Foo()。您throw Foo()在 main 中的第一次调用会创建一个被复制的临时Foo对象，然后调用它的析构函数（副本尚未被抛出）。在那个析构函数中，另一个临时Foo对象被创建、复制，然后被销毁，这会创建另一个临时对象Foo......等等。Foo所以程序一直在复制，直到它崩溃并且从未真正达到它抛出这些异常的地步。

于 2013-10-21T19:58:37.853 回答