1.1.3.2 Inside of new

• source code of new and delete
  Foo* p; 
   // don’t catch exceptions thrown by the allocator itself 
   void* raw = operator new(sizeof(Foo)); 
   
   // catch any exceptions thrown by the ctor 
   try { 
     p = new(raw) Foo();  // call the ctor with raw as this 
   } 
   catch (...) { 
     // oops, ctor threw an exception 
     operator delete(raw); 
     throw;  // rethrow the ctor’s exception 
   } 
   
  ////////////////////////////////////////// 
  if (p != NULL) { 
    p->~Foo(); 
    operator delete(p); 
  }
• void* operator new(size_t size) pseudocode. Detail can be seen effective c++;
  type void (*PEHF) (); 
  void* operator new(size\_t size) pseudocode{ 
  .......... 
  PEHF  currentHandler = set_new_handler(0); 
  // you can’t fetch "current error handler" directly, 
  // You have to use set_new_handler interface. 
  set_new_handler(currentHandler); 
  //In previous set_new, "current error handler" 
  //has been set 0, then use currentHandler to set it back. 
  if(currentHandler) 
     (*currentHandler)(); 
  }
• You can’t change "new operator" behavior, but you can overload "operator new", it just allocate memory block for "new operator".
• You can only want to allocate memory, call operator new, no ctor will be called.
• When do you need to overload operator new, if you need to dynamically allocated a lot of small object, It’s better to overload operator new in your small object class. Detail can be seen in effective C++ and modern design c++ chapter 4.
• If you don’t overload operator new in a derived class, global(default) operate new will still call base operator new which you have overload. So In your base class, It’s better to write
  void * Base::operator new(size_t size){ 
  if(size != sizeof(Base) ) 
     return ::new char[size]; 
     // just allocate raw memory, 
     // it will not call any ctor.
• A good article is "The many faces of operator new in C++", I have added it to my evernote, you can see it if you need in the future.