Big Problem! How to overload operator delete?

[Lighter]

Big Problem! How to overload operator delete?

According to C++ standard, "A deallocation function can have more than
one parameter."(see 3.7.3.2); however, I don't know how to use an
overloaded delete operator. Let me use an example to illustrate this:

/********************************************************/
#include <new>
#include <iostream>

using namespace std;

void operator delete(void* p, const nothrow_t&)
{
cout << "Hello" << endl;
} // (1)

void operator delete(void* p, int a, int b)
{
cout << "World" << endl;
} // (2)

int main()
{
int* p = new(nothrow) int;

delete p; // This cannot render to show 'Hello' or 'World'
}
/********************************************************/

Even if I use 'delete(nothrow, p);', it cannot render to show 'Hello'
or 'World' either. My problem just lies here: Although I can write my
own operator delete, I cannot use it. As far as I know, the C++
standard doesn't give an example to illustrate the usage of delete (The
usage of new is given.).

An ugly way to do this is to use function call:

operator delete(nothrow, p); // This can render to show 'Hello'

However, I don't think this is the answer to my question. Who know the
correct one?

Any help will be appreciatied. Thanks in advance.

 

[Butterfly]

Big Problem! How to overload operator delete?

According to C++ standard, "A deallocation function can have more than
one parameter."(see 3.7.3.2); however, I don't know how to use an
overloaded delete operator. Let me use an example to illustrate this:

/********************************************************/
#include <new>
#include <iostream>

using namespace std;

void operator delete(void* p, const nothrow_t&)
{
cout << "Hello" << endl;
} // (1)

void operator delete(void* p, int a, int b)
{
cout << "World" << endl;
} // (2)

int main()
{
int* p = new(nothrow) int;

delete p; // This cannot render to show 'Hello' or 'World'
}
/********************************************************/

Even if I use 'delete(nothrow, p);', it cannot render to show 'Hello'
or 'World' either. My problem just lies here: Although I can write my
own operator delete, I cannot use it. As far as I know, the C++
standard doesn't give an example to illustrate the usage of delete (The
usage of new is given.).

An ugly way to do this is to use function call:

operator delete(nothrow, p); // This can render to show 'Hello'

However, I don't think this is the answer to my question. Who know the
correct one?

Any help will be appreciatied. Thanks in advance.

Try this

void operator delete(void* ptr)
{
}

 

[Lighter]

Try this

void operator delete(void* ptr)
{
}

This is not what I want.

My question is how to overload the operator delete with multiple
parameters.

 

[Alan Johnson]

This is not what I want.

My question is how to overload the operator delete with multiple
parameters.

You can't, really. The only time an overloaded version of operator
delete is called is when an exception is thrown in the constructor of
the object being constructed. The following example shows the
relationship between them:
#include <cstddef>
#include <new>
#include <iostream>

void * operator new(std::size_t sz)
throw(std::bad_alloc)
{
std::cout << "Normal operator new called." << std::endl ;

void * p = std::malloc(sz) ;
if (!p)
throw std::bad_alloc() ;
return p ;
}

void operator delete(void * p) throw()
{
std::cout << "Normal operator delete called." << std::endl ;
if (p)
std::free(p) ;
}

void * operator new(std::size_t sz, std:stream & out)
throw(std::bad_alloc)
{
out << "Custom operator new called." << std::endl ;
return :perator new(sz) ;
}

void operator delete(void * p, std:stream & out) throw()
{
out << "Custom operator delete called." << std::endl ;
:perator delete(p) ;
}

class T
{
public:
T(bool should_throw) { if (should_throw) throw 1 ; }
} ;

int main()
{
// Calls normal new, normal delete.
T * p = new T(false) ;
delete p ;
std::cout << std::endl ;

// Calls custom new, normal delete.
p = new(std::cout) T(false) ;
delete p ;
std::cout << std::endl ;

// Calls normal new, normal delete.
try
{
T * p = new T(true) ;
delete p ;
}
catch (...)
{}
std::cout << std::endl ;

// Calls custom new, custom delete.
try
{
T * p = new(std::cout) T(true) ;
delete p ;
}
catch (...)
{}
std::cout << std::endl ;
}

 

[Lighter]

To Alan Johnson:

Thank you very very much! Your answer is concise and instructive. You
enlightened me.

 

[sarathy]

Hi,
I just have a small doubt. Can new/delete be overloaded with
any number of parameters (of any types) or is it just "ostream" type
must be used.

Regards,
Sarathy

 

[Alan Johnson]

Hi,
I just have a small doubt. Can new/delete be overloaded with
any number of parameters (of any types) or is it just "ostream" type
must be used.

Regards,
Sarathy

I think that the first parameter to new must always be std::size_t, and
the first parameter to delete a void *. Other than that you can do
whatever you'd like with the rest of the parameters. There are a few
overloads that people will expect to behave in certan ways.

void * operator new(std::size_t sz, const std::nothrow_t &) throw() ;

People expect that to allocate memory without throwing exceptions, and
return NULL if it can't.

void * operator new(std::size_t sz, void * p) throw()
{
return p ;
}

People expect "placement new" to act as above. That is, it just
returns the pointer provided without actually allocating any memory.
Likewise they'll expect the corresponding operator delete to not free
any memory.