Re: Inherited destructor behavior clarification
On Mar 2, 5:52 pm, James Kanze <james.ka...@gmail.com> wrote:
On Mar 2, 6:33 am, annamalai <annamalai.gurus...@gmail.com> wrote:
On Mar 1, 3:00 am, Kevin Brandon <kjbron...@gmail.com> wrote:
template<class T>
class base {
protected:
~base() { }
public:
void destroy() {
delete static_cast<T*>(this);
}
};
class derived : public base<derived> {
// ...
};
void foo() {
derived* p = new derived;
p->destroy();
}
Is above correct, even if derived derives from multiple base classes,
which may or may not derive from base? I thought it can be correct,
since we delete pointer to T and we know everything about T at the
point of deletion.
The following example demonstrates the memory leak that is possible in
the above approach:
You can misuse just about anything. Having a base class which
is a template on the derived class is a common idiom.
[...]
IMHO, it is always better to release the resources in the same class
that acquires it. Why do we want to release the resources acquired by
one class to be released by another class (even if they are related by
a class hierarchy)?
First, what resources are you talking about? His example wasn't
dealing with resources, it was defining the semantics of
a class. And while I don't see the real use of having
a template base class for something that simple, in a lot of
applications, almost all deletes will be delete this. The class
is modeling something external to the program, and reacting to
events. One of those events triggers its destruction.
--
James Kanze
Hi and thanks for your contributions.
Suncho, check out what destroy does. As pointed by James Kanze.
Anna, that's not how that class was used. I know that danger. The code
draft I have proposes something exactly like that.
James, this was a very short discussion between me and a colleague.
What I wanted to refresh/clarify was whether declaring the root base
type's destructor as virtual is enough? or not...
So, in the second example, declaring "base"'s destructor virtual, but
deleting one of the most derived types through a pointer to an
arbitrary type in inheritance hierarchy, I believe, should not trigger
ub.
class base {
public:
virtual ~base() { }
};
class secondBase : public base {
public:
};
class thirdBase : public secondBase {
public:
};
class derived : public thirdBase {
public:
};
void foo() {
thirdBase* p = new derived;
delete p;
}
or should all types declare destructors as virtual, particularly
thirdBase?
Kevin
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]