Re: Proper Destruction of Class Members when an Exception is Thrown
in Destructor
On Feb 27, 9:30 am, anon <sfdhrt...@ebay.de> wrote:
AnonMail2...@gmail.com wrote:
On Feb 26, 12:36 pm, Daniel Pitts
<newsgroup.spamfil...@virtualinfinity.net> wrote:
AnonMail2...@gmail.com wrote:
On Feb 26, 11:03 am, Leandro Melo <ltcm...@gmail.com> wrote:
On 26 fev, 12:47, "AnonMail2...@gmail.com" <AnonMail2...@gmail.com>
wrote:
Can someone point me to the specific are of the standard that will
clarify this issue?
Well, you should start from a very important C++ guideline which say=
s
that destructors should not throw. Never!
If you implement a destructor that might throw you'll be unable to
rely on others well know C++ idioms. Basically, you won't be able to
write exception-safe code and provide any kind of commit-or-rollback
guarantee.
In addition, you'll also be in trouble when using operators like new=
[]
and delete[].
Bottom line: Don't let your destructors throw.
Never use the word never!
Except about "Exceptions leaving Destructors"
The reasoning I've heard is: When an exception is thrown
from any part of your code, the stack starts to unwind.
This includes calling any appropriate destructors. If a
destructor throws an exception, then what is supposed to
happen? Does the new exception take precedence? Does the
old one trump?
The answer is: I don't care, because it is probably not
what I want. Don't let your destructor throw an exception.
Worse case scenario, let the program die immediately.
It is well defined what happens when an exception is thrown
during stack unwinding, so there is no guessing what will
happen.
I found the portion of the standard that actually *answers*
my specific question.
The relevant section is 15.2.2.
I doubt 15.2.2 is relevant, because in 99.99% an exception
thrown from a destructor will terminate the process.
That's simply false. Most of the time, an exception thrown from
a destructor will NOT terminate the process.
Can not think of an example where 0.01% this is not true.
class ThrowsInDestructor
{
public:
~ThrowsInDestructor() { throw 42; }
} ;
int
main()
{
try {
ThrowsInDestructor t ;
std::cout << "t constucted" << std::endl ;
} catch ( int i ) {
return i ;
}
return 0 ;
}
The problem isn't that most of the time, throwing from a
destructor will terminate the process. The problem is
guaranteeing that this will never be the case. Something that
is very difficult, if not impossible, for most general purpose
classes (but there exist a very few, special classes, whose sole
purpose is for the destructor to throw).
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34