How do you overload new operator?

Answer 1

Here's an example of what it would look like to overload new and delete for a particular class. class Myclass { public: void* operator new(size_t); void operator delete(void*); }; Both of them are by default static members and do not maintain a this pointer. Overloading can be used for many purposes. For example, we may need to alter the exception thrown in case of failure--std::bad_alloc--and throw something else: void* Myclass::operator new(size_t size) { void *storage = malloc(size); if(NULL == storage) { throw "allocation fail : no free memory"; } } Usually we do this in a base class in order to have the functionality of the overloaded new in all derived classes. Implicitly the definition of new is included in every file, but in order to use the size_t declaration and other new related types you must include the header .

The new operator can be implemented using malloc or another C function, called realloc, that handles memory allocation: void * realloc ( void * ptr, size_t size ); This can be used to change the size of the allocated block at address ptr with the size given in the second parameter. The address pointed to by ptr can actually be changed and the block moved someplace else, in which case the new address will be the returned value. If realloc fails, like malloc, it returns NULL. But realloc will not free the original memory if your memory allocation request fails. Therefore, when you use realloc, be sure to save the previous pointer value in case allocation fails, so that you do not leak memory.

Note that in general, if you overload new, you will likely need to overload delete, and vice versa, because by changing how you allocate memory, you will typically also change how you free memory.

Operator new is invoked implicitly when new is called; there is no syntax for calling operator new explicitly. #include

#include

#include <new>

using namespace std;

class MyClass {

int x, y;

public:

MyClass() {

x = y = 0;

}

MyClass(int lg, int lt) {

x = lg;

y = lt;

}

void show() {

cout << x << " ";

cout << y << endl;

}

void *operator new(size_t size);

void operator delete(void *p);

void *operator new[](size_t size);

void operator delete[](void *p);

};

// overloaded new operator

void *MyClass::operator new(size_t size)

{

void *p;

cout << "In overloaded new.\n";

p = malloc(size);

if(!p) {

bad_alloc ba;

throw ba;

}

return p;

}

// delete operator overloaded

void MyClass::operator delete(void *p)

{

cout << "In overloaded delete.\n";

free(p);

}

// new operator overloaded for arrays.

void *MyClass::operator new[](size_t size)

{

void *p;

cout << "Using overload new[].\n";

p = malloc(size);

if( !p ) {

bad_alloc ba;

throw ba;

}

return p;

}

// delete operator overloaded for arrays.

void MyClass::operator delete[](void*p)

{

cout << "Freeing array using overloaded delete[]\n";

free(p);

}

int main()

{

MyClass *objectPointer1, *objectPointer2;

int i;

try {

objectPointer1 = new MyClass (10, 20);

} catch (bad_alloc xa) {

cout << "Allocation error for objectPointer1.\n";

return 1;;

}

try {

objectPointer2 = new MyClass [10]; // allocate an array

} catch (bad_alloc xa) {

cout << "Allocation error for objectPointer2.\n";

return 1;;

}

objectPointer1->show();

for( i = 0; i < 10; i++)

objectPointer2[i].show();

delete objectPointer1; // free an object

delete [] objectPointer2; // free an array

return 0;

}