Question

I can override global operator new with different parameters, so for example I can have:

void* operator new (std::size_t size) throw (std::bad_alloc);
void* operator new (std::size_t size, int num) throw (std::bad_alloc);

which can be called separately as

int* p1 = new int; // calls new(size_t)
int* p2 = new(5) int; // calls new(size_t, int)

since each of these can potentially use some different allocation scheme, I would need a separate delete() function for each. However, delete(void*) cannot be overloaded in the same way! delete(void*) is the only valid signature. So how can the above case be handled?

P.S. I am not suggesting this is a good idea. This kind of thing happened to me and so I discovered this “flaw” (at least in my opinion) in c++. If the language allows the new overrides, it must allow the delete overrides, or it becomes useless. And so I was wondering if there is a way around this, not if this a good idea.

Answer 1

If you keep track of the different memory regions you allocate with your different new overloads, you can tag them with the version of new that was called.

Then at delete time you can look the address up to find which new was called, and do something different in each case.

This way you can guarantee that the correct logic is automatically associated with each different new overload.

As pointed out by baruch in the comments below, there is a performance overhead associated with the maintenance of the data you use for tracking, and this logic will also only work as long as the overloaded delete is not passed anything allocated using the default delete.

As far as tracking overhead, it seems to me that the minimum overhead method of tracking the type of the allocation is to allocate the amount requested, plus a small amount of additional space at the start of the allocated region in which to tag the request type (sized according to conservative alignment requirements). You can then look at this tag region on delete to determine which logic to follow.