How to replace delete[] with a macro

[foo]

I'm creating a debug class called debug_mem_alloc ation for the purpose
of finding memory leaks.
I used macro's to replace the new and delete operators.
My problem is with trying to replace the delete[] operator with a
macro.

I can't replace the delete[] operator by using void* as the first
parameter, because then my code will not be able to modify the calling
function's pointer, nor would it get the source file name and line
number.
My current work around has been to modify the source code by replacing
delete[] with DELETE_ARRAY_AN D_NULLIFY, which is defined as delete[]
for NON-DEBUG compile, and defined as an operator-() of my debug class
for DEBUG compile.

Can anyone think of a better way to replace the delete[] operator via
macro that would not require me to modify the source code?

My compilers are VC++ 6.0 and GNU 3.x

Here's the header:

class debug_mem_alloc ation
{
public:
enum ACTION_SWITCH{A llocateMem, DeAllocMem, GenerateReport} ;
debug_mem_alloc ation(const char* FileName, int LineNo, const char*
FunctionName)
:m_FileName(Fil eName), m_LineNo(LineNo ), m_FuncName(Func tionName){}
template<typena me T>
void operator+(T &ptr)
{
Log(ptr, DeAllocMem);
delete ptr;
ptr = NULL;
}
template<typena me T>
void operator+(const T &ptr)
{
Log(ptr, DeAllocMem);
delete ptr;
}
template<typena me T>
void operator-(T &ptr)
{
Log(ptr, DeAllocMem);
delete [] ptr;
ptr = NULL;
}
template<typena me T>
T& operator<<(T &ptr)
{
Log(ptr, AllocateMem);
return ptr;
}
template<typena me T>
void free_and_nullif y(T &memblock , const char* VariableName)
{
Log(memblock, DeAllocMem);
free(memblock);
memblock = NULL;
}
void *malloc_and_log (size_t size );
void *realloc_and_lo g(void *memblock, size_t size );
static void SendOutCurrentL og();
private:
void Log(void const * const Ptr, ACTION_SWITCH Sw);
const char* m_FileName;
const int m_LineNo;
const char* m_FuncName;
};
#if (defined(DEBUG) || defined (_DEBUG)) &&
defined(USE_DEB UG_MEM_ALLOCATI ON)
#define new debug_ext::debu g_mem_allocatio n(__FILE__, __LINE__,
__FUNCTION__)<< new
#define delete debug_ext::debu g_mem_allocatio n(__FILE__,
__LINE__, __FUNCTION__)+
#define DELETE_ARRAY_AN D_NULLIFY debug_ext::debu g_mem_allocatio n(__FILE__,
__LINE__, __FUNCTION__)-
#define malloc(x) debug_ext::debu g_mem_allocatio n(__FILE__,
__LINE__, __FUNCTION__).m alloc_and_log(x )
#define realloc(m,s) debug_ext::debu g_mem_allocatio n(__FILE__,
__LINE__, __FUNCTION__).r ealloc_and_log( m,s)
#define free(x) debug_ext::debu g_mem_allocatio n(__FILE__,
__LINE__, __FUNCTION__).f ree_and_nullify (x, #x)
#else
#define DELETE_ARRAY_AN D_NULLIFY delete []
#endif

[Ron Natalie]

"foo" <ma*******@axte r.com> wrote in message news:c1******** *************** ***@posting.goo gle.com...

I'm creating a debug class called debug_mem_alloc ation for the purpose
of finding memory leaks.
I used macro's to replace the new and delete operators.
My problem is with trying to replace the delete[] operator with a
macro.

You can't replace delete[] with a macro. You can only replace identifires.
Furthermore your code, even with delete, is fraught with perils.
Nothing says that delete has to be given a modifable lvalue.

[foo]

"Ron Natalie" <ro*@sensor.com > wrote in message news:<TK******* *************@g iganews.com>...

"foo" <ma*******@axte r.com> wrote in message news:c1******** *************** ***@posting.goo gle.com...

I'm creating a debug class called debug_mem_alloc ation for the purpose
of finding memory leaks.
I used macro's to replace the new and delete operators.
My problem is with trying to replace the delete[] operator with a
macro.

You can't replace delete[] with a macro. You can only replace identifires.
Furthermore your code, even with delete, is fraught with perils.
Nothing says that delete has to be given a modifable lvalue.

That's why there's an overloaded version of operator+()
template<typena me T>
void operator+(const T &ptr)
{
Log(ptr, DeAllocMem);
delete ptr;
}
The overloaded version with the const does not try to set the pointer
to a NULL, but it does do the logging.
If delete is given an rvalue, this operator is used instead of the
following:
template<typena me T>
void operator+(T &ptr)
{
Log(ptr, DeAllocMem);
delete ptr;
ptr = NULL;
}

The only problems I've seen with this is with VC++ in which I still
get compile errors for something like the following:
delete this;
Which gives me the following error:
error C2667: '-' : none of 2 overload have a best conversion
error C2593: 'operator -' is ambiguous

However, I don't get this error with the GNU compiler, so I'm thinking
this is a bug in VC++.
In any case it's rare to see this type of code, and it can easily be
modified to the following:
foofoo* t = this;
delete t;
Which makes VC++ happy.
fraught with perils suggest to me many problems. Is there something
else you see wrong with the code?

And I still think there's a C++ Guru out there who can think of a
better work-around for delete[] operator then what I have.