Question

在下面的代码中，抛出了两种情况的异常，如main（）所示。

#include <iostream>

// Our own exception classes - just for fun.
class myExceptionClassA 
{
    public:
    myExceptionClassA () {std::cout << "\nWarning: Division by zero isn't allowed.\n";}
};

class myExceptionClassB
{
    public:
    myExceptionClassB () {std::cout << "\nWarning: Division by dividend isn't allowed.\n";}
};

class divisionClass
{
    private:
    int *result;

    public:
    divisionClass () 
    {
        // Allocating memory to the private variable.
        result = new int;
    }

    /* 
        The class function `doDivide`:
        1. Throws above defined exceptions on the specified cases.
        2. Returns the division result.
    */
    int doDivide (int toBeDividedBy) throw (myExceptionClassA, myExceptionClassB)
    {
        *result       = 200000;

        // If the divisor is 0, then throw an exception.
        if (toBeDividedBy == 0)
        {
            throw myExceptionClassA ();
        }
        // If the divisor is same as dividend, then throw an exception.
        else if (toBeDividedBy == *result)
        {
            throw myExceptionClassB ();
        }

        // The following code won't get executed if/when an exception is thrown.
        std :: cout <<"\nException wasn't thrown. :)";

        *result = *result / toBeDividedBy;
        return *result;
    }

    ~divisionClass () 
    {
        std::cout << "\ndddddddddd\n";
        delete result;
    }
};

int main ()
{
    divisionClass obj;
    try
    {
        obj.doDivide (200000);
    }
    catch (myExceptionClassA) {}
    catch (myExceptionClassB) {}

    try
    {
        obj.doDivide (3);
    }
    catch (myExceptionClassA) {}
    catch (myExceptionClassB) {}

    try
    {
        obj.doDivide (0);
    }
    catch (myExceptionClassA) {}
    catch (myExceptionClassB) {}

    try
    {
        obj.doDivide (4);
    }
    catch (myExceptionClassA) {}
    catch (myExceptionClassB) {}

    return 0;
}

- 打印两个异常类打印语句 - 析构函数中的语句只打印一次 - Valgrind没有显示任何内存泄漏。

anisha@linux-y3pi:~/Desktop> g++ exceptionSafe3.cpp -Wall
anisha@linux-y3pi:~/Desktop> valgrind ./a.out 
==18838== Memcheck, a memory error detector
==18838== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al.
==18838== Using Valgrind-3.5.0 and LibVEX; rerun with -h for copyright info
==18838== Command: ./a.out
==18838== 

Warning: Division by dividend isn't allowed.

Exception wasn't thrown. :)
Warning: Division by zero isn't allowed.

Exception wasn't thrown. :)
dddddddddd
==18838== 
==18838== HEAP SUMMARY:
==18838==     in use at exit: 0 bytes in 0 blocks
==18838==   total heap usage: 3 allocs, 3 frees, 262 bytes allocated
==18838== 
==18838== All heap blocks were freed -- no leaks are possible
==18838== 
==18838== For counts of detected and suppressed errors, rerun with: -v
==18838== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2)
anisha@linux-y3pi:~/Desktop>

析构函数不应该被调用3次 - 例外两次，返回语句一次吗？

请解释我失踪的一点。

现在我通过删除main（）中的所有try catch块来尝试它析构函数根本没有被调用？

anisha@linux-y3pi:~/Desktop> valgrind ./a.out 
==18994== Memcheck, a memory error detector
==18994== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al.
==18994== Using Valgrind-3.5.0 and LibVEX; rerun with -h for copyright info
==18994== Command: ./a.out
==18994== 

Warning: Division by dividend isn't allowed.
terminate called after throwing an instance of 'myExceptionClassB'
==18994== 
==18994== HEAP SUMMARY:
==18994==     in use at exit: 133 bytes in 2 blocks
==18994==   total heap usage: 3 allocs, 1 frees, 165 bytes allocated
==18994== 
==18994== LEAK SUMMARY:
==18994==    definitely lost: 0 bytes in 0 blocks
==18994==    indirectly lost: 0 bytes in 0 blocks
==18994==      possibly lost: 129 bytes in 1 blocks
==18994==    still reachable: 4 bytes in 1 blocks
==18994==         suppressed: 0 bytes in 0 blocks
==18994== Rerun with --leak-check=full to see details of leaked memory
==18994== 
==18994== For counts of detected and suppressed errors, rerun with: -v
==18994== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2)
Aborted
anisha@linux-y3pi:~/Desktop>

Answer 1

从方法中抛出异常不会破坏拥有它的对象。只有当它被删除或超出范围（在这种情况下，在main（）的末尾）时才会被销毁并且析构函数被调用。

Answer 2

当您捕获异常时，堆栈在抛出异常的点与捕获异常的点之间“展开”。这意味着这两个点之间范围内的所有自动变量都将被销毁 - try内与catch对应的所有内容都匹配异常。

您的对象obj是main函数中try以外的自动变量。因此，当堆栈展开时它不会被破坏。您的代码依赖于这一事实 - 在第一次catch之后再次调用doDivide，因此最好不要将其销毁。

如果你根本没有捕获异常，那么在程序终止之前，无论堆栈是否被展开（在C ++ 11中为15.3 / 9），它都是实现定义的。它看起来好像在你的第二次测试中，没有任何catch条款，它不是。

这意味着如果您希望RAII对象“正常工作”，那么您不能在程序中允许未捕获的异常。你可以这样做：

int main() {
    try {
        do_all_the_work();
    } catch (...) {
        throw; // or just exit
    }
}

现在可以保证，如果异常转义函数，do_all_the_work中的任何自动变量都将被销毁。缺点是你可能会从调试器中获得更少的信息，因为它已经忘记了未被捕获的异常的原始throw网站。

当然，程序中的代码仍有可能阻止您的obj被破坏，例如通过调用abort()。

Answer 3

消息打印在divisionClass的析构函数中。您只有一个该类型的对象，它会在main结束时被销毁。

Answer 4

当抛出异常时，在调用堆栈的某处有一个匹配的catch处理程序时，保证会发生堆栈展开。您可以像这样简化和可视化堆栈：

+-------------------+
| locals            | obj.doDivide()
+-------------------+
|                   | try {}
+-------------------+
| catch { }         |
|                   | main()
| DivisionClass obj |
+-------------------+

只有堆栈中的部分（在上面的图片中）被解开并且相应的对象被破坏。带有divisonClass对象的堆栈部分保持不变，直到main（）退出。

试试这段代码，看看差异：

void foo()
{
    divisionClass obj;
    obj.doDivide(0);
}

int main()
{
    try {
        foo();
    }
    catch (myExceptionClassA) {
        std::cout << "Check point.\n";
    }
}

当涉及多个异常处理时，何时调用析构函数？

4 个答案: