l2u

Hello..

I have some questions about exception handling in c++..

I know its the best to throw object when exception occurs and I wonder what is the best way to do this.
I was thinking about deriving class from std::exception..

Something like:


I wonder:
Would it be smart to do it this way? How do you guys do it?
Would it be smart to have members for storing last_error and other information?

Maybe it would be good to throw it this way (with description):

Next question:
Show I have more classes to handle different sorts of exceptions?
For instance exception that would make program exit, etc..

Thanks a lot for answers

DaWei

You might want to review the article referenced in my sig (Grumpy on C++ exceptions).

__________________
Abstraction doesn't make it impossible to write bad code; it makes it possible to write superior code.
Contributor's Corner: Grumpy on C++ Exceptions DaWei on Pointers

grumpy

That little article referred to by Dawei covers broader questions than l2u's.

std::exception supplies a virtual function of the form;
that classes derived from it must override. That technique is sufficient if the only information about an error that needs to be returned to the caller is simple (eg the type of the exception thrown and a string describing the exception).

Generally, I'm an advocate of having a number of small and simple exception classes (one for each class of error) which allows it to be caught and handled. At most, I may pass some simple data back (eg some error codes) as data members. In practice, I rarely create classes derived from std::exception.

It is never a good idea for an exception class (whether derived from std::exception or not) to rely on dynamic memory allocation (which means an exception class can not have a member which is an std::string or any other standard container). The reason is that a failure during creation of the exception (or copying, as is required during stack unwinding) can cause confusion (eg caller receiving a different exception from that intended).

I never write an exception to "make a program exit". If I want a program to exit, I call exit() or abort(). Exceptions are an error reporting mechanism, not a program termination mechanism. If I throw an exception, it means I expect that a caller has some (albeit, often small in practice) chance of recovering from the error and the error is severe enough that it shouldn't be ignored. If the caller neglects to handle an exception, then the caller (or more accurately the programmer who wrote the caller) accepts that a consequence is program termination.