Re: Virtual Destructor - Implication & Specification

alfps@start.no (Alf P. Steinbach) wrote (abridged):


This scheme, of the destructor returning the size to delete, won't work if
the derived class has its own delete operator. So I doubt it is what
happens in a typical implementation.

What might work is returning a pointer to that operator, either in
addition to the size or with the size being found some other way. (But see
below for a more realistic scheme.)

Making the destructor virtual would not fix the mismatched heap problem if
the implementation uses the "return a size" scheme, but would fix it if it
returns a pointer. Indeed, any scheme which gets the derived operator
delete right would seem amenable to this solution.

However, in principle the compiler can be smart enough to know whether the
base class has any derived classes that have their own delete operators,
and if that doesn't happen, it can use the "return a size" implementation
for that class. In which case making the destructor virtual wouldn't fix
the bug.

In practice the implementation is very unlikely to do that, especially
where DLLs are involved, because it's so hard to know about all the
derived classes (and I doubt there's any benefit to it). However, I don't
think the standard forbids it. Nor does Stroustrup's book. So I think the
virtual destructor solution is implementation-specific.

In addition, since this mismatched heap problem only arises if we've
violated the One Definition Rule (by having two definitions of the heap
functions at some level), the standard allows anything to happen anyway.

Incidently, I think a more realistic scheme is to do the deallocation in
the base class destructor, and pass the size to it, and pass zero if no
deallocation is needed. Like:

     void Base::~Base() {
         Base::~Base( sizeof( Base ) );
     }

     void Base::~Base( size_t sz ) {
         // set vtable pointer.
         // user destructor code.
         // destroy locals.
         if (sz)
             operator delete( this, sz );
     }

     void Derived::~Derived() {
         Derived::~Derived( sizeof( Derived) );
     }

     void Derived::~Derived( size_t sz ) {
         // set vtable pointer.
         // user destructor code.
         // destroy locals.
         Base::~Base( sz );
     }

Then if there is a class-specific delete operator, we can have:

     void Derived::~Derived( size_t sz ) {
         // set vtable pointer.
         // user destructor code.
         // destroy locals.
         Base::~Base( 0 ); // Suppress base deallocation.
         if (sz)
             Derived::operator delete( this, sz );
     }

instead. With this scheme we again find that making the destructor virtual
fixes the mismatched heap problem.

-- Dave Harris, Nottingham, UK.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]