overriding new

[thehustler]

I've implemented a new operator with a parameter in one of my classes as such:


class test
{
public:
static void* operator new (size_t size, int somevalue)
{
return malloc(size);
}
};



However, because I'm defining a parametered new operator, the default new operator ceases to exist and I get compiler errors if I want to instance an object using the default new.

Is there any way to keep the default new operator or do I have to redefine it manually?

[Improving]

I think you either have to redefine it manually or provide default arguments for all parameters except the size_t.

[Kheun]

Beside providing a default operator new, you also have to provide a corresponding operator delete.


#include <iostream>
using namespace std;

class test
{
public:
test()
{
cout << "test::test()" << endl;
}
~test()
{
cout << "test::~test()" << endl;
}

static void *operator new(size_t size, int value)
{
cout << "placement new" << endl;
return malloc(size);
}

static void *operator new(size_t size)
{
cout << "operator new" << endl;
return ::operator new(size);
}

static void operator delete(void *p, int value)
{
cout << "placement delete" << endl;
free(p);
}

static void operator delete(void *p)
{
cout << "operator delete" << endl;
::operator delete(p);
}
};


int main(void)
{

test *p1 = new(1) test;
p1->~test(); // Required to directly call the destructor because placement delete never invoke it.
test::operator delete (p1, 1);

test *p2 = new test;
delete p2;

return 0;
}

[thehustler]

Yeah thanks, I was aware of that, just couldn't be bothered putting it in the example :p

I guess I just have to redefine it then.

[Graham]

Have you tried test* p = ::new test; ? (Note the scope resolution operator.)

[Graham]

Just to clarify my last answer, here's section 5.3.4/9 of the standard:
If the new-expression begins with a unary :: operator, the allocation function’s name is looked up in the global scope. Otherwise, if the allocated type is a class type T or array thereof, the allocation function’s name is looked up in the scope of T. If this lookup fails to find the name, or if the allocated type is not a class type, the allocation function’s name is looked up in the global scope. (Note that, by supplying an operator new in class scope, you are hiding the global one.)