2

在下面的代码中，如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 次 - 两次用于异常，一次用于 return 语句？

请解释我所缺少的观点。

现在我通过删除 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>
4

4 回答 4

3

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

于 2012-06-13T09:29:55.870 回答
3

当您捕获异常时，堆栈在抛出异常的点和捕获异常的点之间“展开”。这意味着这两个点之间范围内的所有自动变量都被破坏了——其中的所有内容都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如果异常转义函数，其中的任何自动变量都将被销毁。缺点是您可能从调试器中获得的信息较少，因为它忘记了未捕获异常的原始抛出位置。

当然，您的程序中的代码仍然可以防止您obj被破坏，例如通过调用abort().

于 2012-06-13T10:33:11.847 回答
2

消息打印在 的析构函数中divisionClass。您只有一个该类型的对象，该对象在main.

于 2012-06-13T09:28:54.123 回答
0

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";
    }
}
于 2012-06-13T10:40:58.997 回答