By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
449,412 Members | 993 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 449,412 IT Pros & Developers. It's quick & easy.

If declared as virtual in base, its derived version also is virtual. Why not for destructors?

P: n/a
When a member function is declared as virtual in the base class, the
derived class versions of it are always treated as virtual.

I am just wondering, why the same concept was not used for the
destructors.
What I am expecting is, if the destructor is declared as virtual in
base, the destructors of all its derived classes also should be
virtual always.
What exactly is the reason for not having it so?

Thanks!
Jul 22 '05 #1
Share this Question
Share on Google+
7 Replies


P: n/a
qazmlp wrote in news:db**************************@posting.google.c om in
comp.lang.c++:
When a member function is declared as virtual in the base class, the
derived class versions of it are always treated as virtual.

I am just wondering, why the same concept was not used for the
destructors.
What I am expecting is, if the destructor is declared as virtual in
base, the destructors of all its derived classes also should be
virtual always.
What exactly is the reason for not having it so?


It is So, you have been missinformed.

Rob.
--
http://www.victim-prime.dsl.pipex.com/
Jul 22 '05 #2

P: n/a
qazmlp wrote:
When a member function is declared as virtual in the base class, the
derived class versions of it are always treated as virtual.

I am just wondering, why the same concept was not used for the
destructors.
What I am expecting is, if the destructor is declared as virtual in
base, the destructors of all its derived classes also should be
virtual always.
What exactly is the reason for not having it so?


Uh, constructors can't be virtual. Destructors inherit virtuality. What
evidence are you working with?

--
Phlip
http://industrialxp.org/community/bi...UserInterfaces
Jul 22 '05 #3

P: n/a
qazmlp posted:
When a member function is declared as virtual in the base class, the
derived class versions of it are always treated as virtual.

I am just wondering, why the same concept was not used for the
destructors.
What I am expecting is, if the destructor is declared as virtual in
base, the destructors of all its derived classes also should be
virtual always.
What exactly is the reason for not having it so?

Thanks!

Bullshit.
class Mammal
{
public:

virtual ~Mammal() {}
}

class Primate : public Mammal {};

class Human : public Primate {};

int main()
{
Mammal* john = new Human;

delete john;
}

-JKop
Jul 22 '05 #4

P: n/a
JKop wrote:
Bullshit.
One can usually masquerade such derision within false diplomacy...

class Mammal
{
public:

virtual ~Mammal() {}
}

class Primate : public Mammal {};

class Human : public Primate {};

int main()
{
Mammal* john = new Human;

delete john;
}


That applies the test "it compiles, runs, and does not crash".

To apply the test "my compiler interprets the standard like this", put a
cout statement inside the derived destructor.

--
Phlip
http://industrialxp.org/community/bi...UserInterfaces
Jul 22 '05 #5

P: n/a
Phlip posted:
To apply the test "my compiler interprets the standard like this", put a cout statement inside the derived destructor.

I prefered my way. If the person is bothered, they'll do
what needs to be done. If they're not bothered, my
assistance will have been of no benefit.
-JKop

Jul 22 '05 #6

P: n/a
JKop <NU**@NULL.NULL> wrote in message news:<Rn*****************@news.indigo.ie>...

[snip]
What I am expecting is, if the destructor is declared as virtual in
base, the destructors of all its derived classes also should be
virtual always.
What exactly is the reason for not having it so?
Bullshit. class Mammal
{
public: virtual ~Mammal() {}
} class Primate : public Mammal {}; class Human : public Primate {}; int main()
{
Mammal* john = new Human; delete john;
}


How does this illustrate that the "virtual-ness" of destructors is inherited?

/david
Jul 22 '05 #7

P: n/a

"qazmlp" <qa********@rediffmail.com> wrote in message
news:db**************************@posting.google.c om...
When a member function is declared as virtual in the base class, the
derived class versions of it are always treated as virtual.

I am just wondering, why the same concept was not used for the
destructors.
What I am expecting is, if the destructor is declared as virtual in
base, the destructors of all its derived classes also should be
virtual always.
What exactly is the reason for not having it so?

Thanks!


But it *is* so!

Try this test: write a class A, with a virtual destructor. Write a class B
publicly deriving from A, but declare its destructor *without* the virtual
keyword. Then write a third class C publicly deriving from B, again without
the virtual keyword in the destructor declaration. Put some cout code in
each destructor to see which ones get called. In main (or some other
function), declare a B* pointer, and instantiate it via "new C()". Then
call delete on the pointer. You should see that the destructor for C is
called. That's because the destructor for B is virtual, even though you
didn't give it the virtual keyword. The only place you had the virtual
keyword was in the A class, yet you're able to delete a C object via a
pointer to a B object, which is only possible if the base class (B) has a
virtual destructor. So B must have inherited the "virtualness" of its
destructor from A. Q.E.D.

(But, I would advise you to always add the virtual keyword to any function
that overrides a base class' virtual function, including your destructors,
just so you don't have to go hunting up the inheritance tree later to see if
a function is inheriting virtual behavior or not.)

-Howard

Jul 22 '05 #8

This discussion thread is closed

Replies have been disabled for this discussion.