Re: Exception in Constructor
On 16.09.2012 09:45, Henry wrote:
I am confused by the "note section" at
http://www.parashift.com/c++-faq/ctors-can-throw.html
It says, "if a constructor finishes by throwing an exception, the
memory associated with the object itself is cleaned up ? there is no
memory leak".
However, as I know (and I tested), when an exception is thrown
inside a constructor, the destructor won't be called.
First, it is *very* important to proceed reading with the very next
paragraph of this text, starting with:
"There is some fine print on this topic, so you need to keep
reading. [..]"
Among other things you will find
"If a constructor throws an exception, the object's destructor is not
run."
Here is how I tested:
#include <iostream>
[..]
class A {
public:
A() {
m_b = new B(3);
throw 0;
}
This test situation does not test what the wording says, which was
(emphasis mine):
"[..] the memory associated with the object **itself** is cleaned up
[..]"
There does **not** exist any magic within constructors that prevents
the leaking of the allocated memory that is followed by the exception.
The guarantee that exists is that the destructors for all fully
constructed members and base classes **at the point of the exception**
will be called. In your example the only full constructed sub-object
is the member m_b and the destructor of the object is a no-op.
Further, the guarantee exists that if the overall object to be
constructed was allocated by a new expression, the matching
deallocation function will be called. This situation does not arise in
your test program either.
Inside A::A(), I new-ed B and then threw an exception on purpose,
and obviously, A::~A() and B::~B() weren't called.
It doesn't seems to me that "if a constructor finishes by throwing
an exception, the memory associated with the object itself is
cleaned up ? there is no memory leak" is true.
The memory allocated by the expression "new B(3)" is not associated
with the object itself. If instead of a built-in pointer you would
have used a smart pointer type, like std::auto_ptr, std::unique_ptr,
...., the destructor of this member would have been called and the
allocated memory would be freed. You test code is a very good example
*why* to use such self-administarting members.
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]