Thread: exception handling

Which of the following statements describe correct methods of handling C++ exceptions?

A. In a hierarchy of exception classes, the order of handling exceptions can be from the most specific class to the most general class.
B. Once an exception is thrown, the compiler unwinds the heap, freeing any memory dynamically allocated within the block from which the exception was thrown.
C. If an exception is caught by its address or pointer, it is the responsibility of the thrower to release the memory occupied by the exception.
D. Catching an exception by reference is preferable to catching it by value.
E. To write an exception handler, it is essential to know the concrete class of exception to catch.

Ok,
* A is correct, because ya can do exception handling anywhere.
* B is incorrect, becuase you need to free the memory yourself when you do a try/catch
* C is correct, because of what I said about B
* D is correct, because it you just have its value you can't free its reference.
* E - unsure, I don't understand the answer.

Can someone please confirm/comment? Thx.

A. Wrong reason. Can you catch more than one exception type at one level?

Code:

try {
   ...
}
catch (std::bad_alloc&) {
    ...
}
catch (std::exception& {
    ...
}

C. Wrong answer and wrong reason. (In practice you probably wouldn't do that anyway.)

Consider:

Code:

#include <iostream>
#include <stdexcept>

int main()
{
    std::runtime_error err("Oh");
    try {
        throw &err;
    }
    catch (std::exception* e) {
        std::cout << e->what();
    }
}

D. The explanation makes no sense. Why would you prefer passing objects to functions by reference? What about hierarchies of exception objects?

E. Can you write a catch block that catches an exception, if you don't know whether a std::bad_alloc or std::range_error (or any other exception is thrown).

E. To write an exception handler, it is essential to know the concrete class of exception to catch.

This is basically stating that you can only catch concrete exceptions, not abstract ones.

What do you think -- is this true?