C++ RAII 不工作？

Question

我刚刚开始使用 C++ 中的 RAII 并设置了一个小测试用例。 要么我的代码非常混乱，要么 RAII 不起作用！ （我猜是前者）。

如果我运行：

#include <exception>
#include <iostream>
class A {
public:
    A(int i) { i_ = i; std::cout << "A " << i_ << " constructed" << std::endl; }
    ~A() { std::cout << "A " << i_ << " destructed" << std::endl; }
private:
    int i_;
};

int main(void) {
    A a1(1);
    A a2(2);
    throw std::exception();
    return 0;
}

并注释掉异常，我会得到：

A 1 constructed
A 2 constructed
A 2 destructed
A 1 destructed

正如预期的那样，但除了异常之外，我得到：

A 1 constructed
A 2 constructed
terminate called after throwing an instance of 'std::exception'
  what():  std::exception
Aborted

所以我的对象不会被破坏，即使它们超出了范围。 这不是 RAII 的全部基础吗？

非常感谢指点和更正！

Answer 1

您没有异常处理程序。 当发生这种情况时，标准表示调用 std::terminate，而 std::terminate 又调用 abort。 请参阅《C++ 编程语言》第 3 版第 14.7 节。

Answer 2

问题是 main 具有特殊的地位。 当从那里抛出异常时，堆栈无法有意义地展开，应用程序只是调用 std:terminate 来代替。

那么为什么变量不会超出范围就有点道理了。 我们实际上并没有离开它们声明的范围。 发生的情况可以被认为与此相同：（

int main(void) {
  A a1(1);
  A a2(2);
  std::terminate();
}

我相信在这种情况下是否调用析构函数是实现定义的，因此在某些平台上，它会按您的预期工作）

Answer 3

您在 main 中有一个未处理的异常，这意味着调用终止。 尝试这个：

int main(void)
{
    try
    {
        A a1(1);
        A a2(2);
        throw std::exception();
        return 0;
    }
    catch(const std::exception & e)
    {
        return 1;
    }


}

Answer 4

如果异常从 main() 中逃脱，则这是实现定义的天气堆栈被展开。

尝试

int main()
{
    try
    {
        doWork(); // Do you experiment here. 
    }
    catch(...)
    {   /*
         * By catching here you force the stack to unwind correctly.
         */
        throw;  // re-throw so exceptions pass to the OS for debugging.
    }
}

Answer 5

正如其他人指出的那样，您遇到了一个未捕获的异常，它调用了 Terminate()。 在这种情况下是否调用析构函数是实现定义的（参见标准，15.3第9段和15.5.1第2段），并且您的实现中的定义显然是“不，他们不会”。 （如果由于抛出没有处理程序的异常之外的任何其他原因调用终止（），则不会调用析构函数。）

Answer 6

您的 A 对象不会被销毁，因为正在调用 std::terminate 。

当未处理的异常从 main 中泄漏时，将调用 std::terminate。 如果您将代码包装在 try/catch 中（即使 catch 只是重新引发），您将看到您期望的行为。

Answer 7

您没有正确处理异常，因此您的应用程序在对象超出范围之前退出。

我将再解释一下。 如果异常“冒泡”到主堆栈，则堆栈将被展开（编辑）。 即使将代码移至辅助功能也无法解决此问题。 例如：

      1 #include <exception>
      2 #include <iostream>
      3
      4 void test();
      5
      6 class A {
      7     public:
      8         A(int i) { i_ = i; std::cout << "A " << i_ << " constructed" << std::endl; }
      9         ~A() { std::cout << "A " << i_ << " destructed" << std::endl; }
     10     private:    int i_;
     11 };
     12
     13
     14 int main(void) {
     15     test();
     16     return 0;
     17 }
     18
     19 void test(){
     20             A a1(1);
     21             A a2(2);
     22            throw std::exception();
     23 }

上面的代码不会解决问题。 解决这个问题的唯一方法是将抛出的异常包装在 try-catch 块中。 这将阻止异常到达主线程，并在对象超出范围之前停止发生的终止。

Answer 8

其他人建议在 main() 中放置一个 try/catch 来处理这个问题，效果很好。 出于某种原因，我发现很少使用的“function-try-block”看起来更好，这让我感到惊讶（我认为它看起来太奇怪了）。 但我不认为有任何真正的优点：

int main(void) 
try
{
    A a1(1);
    A a2(2);
    throw std::exception();
    return 0;
}
catch (...) 
{
    throw;
}

有几个缺点，因为它很少被使用，所以很多开发人员看到它时都会陷入困境，如果考虑到这一点，VC6 就会被它噎住。

Answer 9

由于异常在到达 main() 时未得到处理，因此会导致调用 std::terminate()，因此本质上相当于

int main(void) {
  A a1(1);
  A a2(2);
  exit(1);
}

在程序在运行之前终止的情况下不保证调用析构函数超出范围。 对于 RAII 中的另一个漏洞，请考虑：

int main(void) {
  A *a1 = new A(1);
}

Answer 10

以下代码有效。

#include <exception> 
#include <iostream> 

class A { 
public: 
    A(int i) { i_ = i; std::cout << "A " << i_ << " constructed" << std::endl; } 
    ~A() { std::cout << "A " << i_ << " destructed" << std::endl; } 
private: 
    int i_; 
}; 

void test() {
    A a1(1); 
    A a2(2); 
    throw std::exception(); 
} 

int main(void) { 
 try {
  test();
 } catch(...) {
 }
    return 0; 
}