Re: Virtual calls upon destruction

From:

Thomas Richter <thor@math.TU-Berlin.DE>

Newsgroups:

comp.lang.c++.moderated

Date:

1 Nov 2006 09:59:20 -0500

Message-ID:

<4qrik9FogluqU1@news.dfncis.de>

Jeremy Jurksztowicz wrote:

I have a class heirarchy which has a uninitialize() virtual member
function, which aught to be called upon destruction. I know that
putting it in the destructor will not work,

At least not in the intended way - the derived object is already
destroyed and the call will resolve to a method in the base (or below).

so I came up with the
following solution. Aside from any aesthetic and maintenance problems
(I am aware of a few), is this technique portable?

Short and simple: No. How a compiler uses the memory for an object
is an implementation detail, and whether the first memory address
allocated is identical to the first memory address of the object is
undefined.

class Base
{
public:
    virtual ~Base ();
    virtual void uninitialize ( ) = 0;
    virtual void deleteMe (void * ptr, std::size_t sz)
    { ::operator delete(ptr, sz); }
    // ...

    static void operator delete (void * ptr, std::size_t sz)
    {
        if(ptr)
        {
            Base * bptr = reinterpret_cast<Base*>(ptr);
            bptr->uninitialize();
            bptr->deleteMe(ptr, sz);
        }
    }
};

Question is: aparently your derived object holds a couple of resources
that must be released when it gets destroyed. What speaks against
releasing these resources directly in the destructor of the derived object?

So long,
    Thomas

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