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

[qazmlp]

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!

 

[Rob Williscroft]

qazmlp wrote in 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.

 

[Phlip]

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?

 

[JKop]

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

 

[Phlip]

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.

 

[JKop]

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

 

[David Rubin]

[snip]

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

 

[Howard]

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