namespace std
{typedef void (*new_handler)();new_handler set_new_handler(new_handler p) throw();
}

void OutOfMem()
{cerr << "Unable to satisfy request for memory" << endl;abort();
}
int main()
{set_new_handler(OutOfMem);int *ptr = new int[100000000L];return 0;
}

class Widget { ... };
Widget *pw1 = new Widget;            // throws bad_alloc if allocation fails
if (pw1 == 0) ...                    // this test must fail
Widget *pw2 =new (std::nothrow)  Widget;    // returns 0 if allocation for the Widget fails
if (pw2 == 0) ...                            // this test may succeed

void * operator new(std::size_t size) throw(std::bad_alloc)
{                                            // your operator new mightusing namespace std;                    // take additional paramsif (size == 0) {                        // handle 0-byte requestssize = 1;                            // by treating them as 1-byte requests
    }while (true) {attempt to allocate size bytes;if (the allocation was successful)return (a pointer to the memory);// allocation was unsuccessful; find out what the// current new-handling function is (see below)new_handler globalHandler = set_new_handler(0);set_new_handler(globalHandler);if (globalHandler) (*globalHandler)();else throw std::bad_alloc();}
}

void * Base::operator new(std::size_t size) throw(std::bad_alloc)
{if (size != sizeof(Base))  // if size is "wrong,"return ::operator new(size) ; // have standard operator// new handle the request... // otherwise handle// the request here
}

class Base { // same as before, but now
public: // operator delete is declaredstatic void * operator new(std::size_t size) throw(std::bad_alloc);static void operator delete(void *rawMemory, std::size_t size) throw();...
};
void Base::operator delete(void *rawMemory, std::size_t size) throw()
{if (rawMemory == 0) return; // check for null pointerif (size != sizeof(Base)) {  // if size is "wrong,"::operator delete(rawMemory);  // have standard operatorreturn;  // delete handle the request
    }deallocate the memory pointed to by rawMemory;return;
}

Widget *pw = new Widget;

void* operator new(std::size_t) throw(std::bad_alloc);

void operator delete(void *rawMemory) throw();                        // normal signature at global scope
void operator delete(void *rawMemory, std::size_t size) throw();    // typical normal signature at class scope 

class Widget {
public:...static void* operator new(std::size_t size, // non-normalstd::ostream& logStream)                    // form of newthrow(std::bad_alloc);static void operator delete(void *pMemory    // normal class-std::size_t size) throw();                // specific form// of delete
    ...
};

void* operator new(std::size_t, void *pMemory) throw();

Widget *pw = new (std::cerr) Widget; // call operator new, passing cerr as// the ostream; this leaks memory// if the Widget constructor throws

void operator delete(void *, std::ostream&) throw();

class Base {
public:...static void* operator new(std::size_t size, // this new hides the normal global formsstd::ostream& logStream) throw(std::bad_alloc); ...
};
Base *pb = new Base;                // error! the normal form of// operator new is hidden
Base *pb = new (std::cerr) Base;    // fine, calls Base's// placement new

class Derived: public Base {                        // inherits from Base above
public:...static void* operator new(std::size_t size) // redeclares the normalthrow(std::bad_alloc);                        // form of new
    ...
};
Derived *pd = new (std::clog) Derived;    // error! Base's placement// new is hidden
Derived *pd = new Derived;                // fine, calls Derived's// operator new

void* operator new(std::size_t) throw(std::bad_alloc); // normal new
void* operator new(std::size_t, void*) throw(); // placement new
void* operator new(std::size_t,                // nothrow new — see Item 49const std::nothrow_t&) throw();            

class StandardNewDeleteForms {
public:// normal new/deletestatic void* operator new(std::size_t size) throw(std::bad_alloc){ return ::operator new(size); }static void operator delete(void *pMemory) throw(){ ::operator delete(pMemory); }// placement new/deletestatic void* operator new(std::size_t size, void *ptr) throw(){ return ::operator new(size, ptr); }static void operator delete(void *pMemory, void *ptr) throw(){ return ::operator delete(pMemory, ptr); }// nothrow new/deletestatic void* operator new(std::size_t size, const std::nothrow_t& nt) throw(){ return ::operator new(size, nt); }static void operator delete(void *pMemory, const std::nothrow_t&) throw(){ ::operator delete(pMemory); }
};class Widget: public StandardNewDeleteForms {            // inherit std forms
public:using StandardNewDeleteForms::operator new;            // make thoseusing StandardNewDeleteForms::operator delete;        // forms visiblestatic void* operator new(std::size_t size,             // add a customstd::ostream& logStream)                        // placement newthrow(std::bad_alloc);static void operator delete(void *pMemory,            // add the corresponding placement deletestd::ostream& logStream)                        throw(); ...
};