Re: Overloading operator delete problem
Jens Theisen wrote:
"kanze" <kanze@gabi-soft.fr> writes:
It just occured to me that the classical placement new (as
opposed to the nothrows), doesn't follow that pattern. The
following is obviously illegal, ptr should be destroyed by a
call to ~A.
int main()
{
A *ptr = (A*)malloc(sizeof(A));
ptr = new (ptr) A;
delete ptr;
free(ptr);
}
I'm not sure what your trying to say, but the code above is
illegal. You do NOT use the operator delete on a pointer
returned from the classical placement new. You explicitly call
the destructor, i.e. the last two lines above should be:
ptr->~A() ;
free( ptr ) ;
There is a placement form of the operator delete function for
the classical placement new. It does nothing. It will only be
called, however, if the constructor for A throws. (Note that
when separating allocation and initialization in this manner, it
is your responsibility to free the memory if the constructor
throws.)
Also note that because the non-placement delete is called
for normal deletes, if you provide a special placement new
of your own, you also have to replace the non-placement
operator delete, AND the non-placement operator new,
ensuring that in all of the operator new's, you do something
so that the non-placement operator delete can tell how to
dispose of the memory.
Or you provide a custom delete function for your type. Then
you can't delete them with delete, of course, but you also
can't delete with delete what you've allocated by classic
placement new.
So actually we have:
allocated by | deleted by
new delete
new (nothrow) delete
new (void*) ~T
new (custom_t) custom-defined
More or less.
The problem is that placement new has several uses. In the case
of new(void*), it's really just a hack to call the constructor,
and not a "new" at all, except formally. In other cases, the
issue is more subtle. When using custom allocators with
placement new, for example, it is usual to take over all of the
memory management, so that the standard delete can be used
everywhere. (I'm not sure, but I think that the standard
implementation of new(nothrow) is required to use plain new, so
that just replacing plain new and plain delete should be
sufficient there.)
If this rule is followed, placement new's fall into two
categories: either you use delete, or you invoke the destructor
directly, with no call to delete. In my experience, the
classical placement new is in fact about the only case of the
latter.
--
James Kanze GABI Software
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]