Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > Big Problem! How to overload operator delete?

Reply
Thread Tools

Big Problem! How to overload operator delete?

 
 
Lighter
Guest
Posts: n/a
 
      08-10-2006
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.

 
Reply With Quote
 
 
 
 
Butterfly
Guest
Posts: n/a
 
      08-10-2006

Lighter wrote:
> 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)
{
}

 
Reply With Quote
 
 
 
 
Lighter
Guest
Posts: n/a
 
      08-10-2006
Butterfly wrote:
> 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.

 
Reply With Quote
 
Alan Johnson
Guest
Posts: n/a
 
      08-10-2006
Lighter wrote:
> Butterfly wrote:
>> 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.
>


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 ;
}

--
Alan Johnson
 
Reply With Quote
 
Lighter
Guest
Posts: n/a
 
      08-10-2006
To Alan Johnson:

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

 
Reply With Quote
 
sarathy
Guest
Posts: n/a
 
      08-10-2006
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

 
Reply With Quote
 
Alan Johnson
Guest
Posts: n/a
 
      08-10-2006

sarathy wrote:
> 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.

--
Alan Johnson

 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Re: How include a large array? Edward A. Falk C Programming 1 04-04-2013 08:07 PM
GIDS 2009 .Net:: Save Big, Win Big, Learn Big: Act Before Dec 29 2008 Shaguf ASP .Net 0 12-26-2008 09:29 AM
GIDS 2009 Java:: Save Big, Win Big, Learn Big: Act Before Dec 29 2008 Shaguf Python 0 12-24-2008 07:35 AM
function overload (not operator overload) Ying-Chieh Liao Perl Misc 3 10-11-2004 11:24 AM
How use the overload of>> (or<<) of a class in the overload of << and >> of another class? Piotre Ugrumov C++ 3 01-25-2004 08:08 PM



Advertisments