Re: Overlaoded delete , strange behaviour!

rohits123@gmail.com wrote:


Ehem, you're confusing class construction/deletion with memory
allocation/release.

A "new expression" as in the first line does two things: It first
calls the corresponding operator new to get the memory, then
calls the constructor. Similarly, a "delete expression" as in

delete s1;

first calls the destructor, then the corresponding operator delete.


Right, it doesn't, and it shouldn't. That's what the delete expression
does. Here you only call the operator delete, which *only* releases
memory and nothing else.


You could to fix your program, but I recommend to use a delete
expression instead and implement memory pools properly. It's not
easy to do that correctly, though.


First of all, it seems that you want to implement a memory
pool by your overloaded new/delete operators. It is very important
to know that the delete expression calls this operator delete:

operator delete(void *mem);

or

operator delete(void *mem,size_t size);

which is probably not what you expect. Yes, that's the operator
delete *without* any additional argument. The operator delete with
the additional argument you use for memory pools is *only* called in
case a new expression fails in the construction of a class as in:

MyClass::MyClass(...)
        : m_pMyImpl(new(POOL) ImplClass)
                    ^^^^^^^^^^^^^^^^^^^^
                If this new throws, the operator delete with extra
                argument is called.
{
}

MyClass::~MyClass()
{
        delete m_pMyImpl;
        ^^^^^^^
This delete expression calls the regular operator delete, regardless
how m_pMyImpl has been constructed.
}

The trick is that you need to keep the pool within the memory
allocated by your overloaded operator new, i.e. allocate the amount of
memory passed into operator new, plus additional memory for keeping
(for example) one pointer to the pool, plus some alignment that is
machine dependent. In operator delete(), retrieve the pointer to the
pool from the raw memory.

So long,
        Thomas

P.S.: Yes, that's wierd indeed. Traditionally, the "additional argument"
for the operator new has been used for "placement new", i.e. construct
a class in already available "raw" memory, and then the corresponding
delete operator can be just a no-op. Unfortunately, this design
decision makes it rather hard to implement memory pools, and furthermore
makes it a somewhat machine dependent affair as well as you need to keep
track of the required alignment for the memory to construct the classes
in. I wonder whether the standardization committee has any plans to fix
this issue.

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