What are the principles guiding your exception handling policy?
error-handling, exception
Solution
Exceptions should not be used as a method of passing information internally between methods inside your object, locally you should use error codes and defensive programming.
Exceptions are designed to pass control from a point where an error is detected to a place (higher up the stack) where the error can be handled, presumably because the local code does not have enough context to correct the problem and something higher up the stack will have more context and thus be able to better organize a recovery.
When considering exceptions (in C++ at least) you should consider the exception guarantees that your API makes. The minimum level of guarantee should be the Basic guarantee though you should strive (where appropriate) to provide the strong guarantee. In cases where you use no external dependencies from a articular API you may even try to provide the no throw guarantee.
N.B.Do not confuse exception guarantees with exception specifications.
Exception Guarantees:
No Guarantee:
There is no guarantee about the state of the object after an exception escapes a method In these situations the object should no longer be used.
Basic Guarantee:
In nearly all situations this should be the minimum guarantee a method provides. This guarantees the object's state is well defined and can still be consistently used.
Strong Guarantee: (aka Transactional Guarantee)
This guarantees that the method will completely successfully Or an Exception will be thrown and the objects state will not change.
No Throw Guarantee:
The method guarantees that no exceptions are allowed to propagate out of the method. All destructors should make this guarantee. | N.B. If an exception escapes a destructor while an exception is already propagating | the application will terminate
Problem
There is a lot of relativity involved in working with exceptions. Beyond low level APIs where exceptions cover errors raised from hardware and the OS there is a shady area where the programmer decides what constitutes an exception and what is a normal condition. How do you decide when to use exceptions? Do you have a consistent policy regarding exceptions?