Inside of new

Source code of new operator and delete operator.

call operator new to allocate a space in memory.
call ctor of a class.
If you want to allocate memory, call operator new, not new opeator, in this way, ctor will not be called.
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 throw an exception
   operator delete(raw);
   throw;  // rethrow the ctor’s exception
}
Source code of delete operator. So for a class, if you declare its dtor private or protected, You can’t use "delete p".
/* delete operator */
if (p != NULL) {
p->~Foo();
operator delete(p);
}

You can’t change "new operator" behavior, but you can override global "operator new" and overload class its own "operator new". Pay attention its argument and return void*

//global operator new
____________ void* operator new(_____________________size_t size){
   cout<<"Yan’s␣own␣operator␣new" ;
   void* mem = malloc(size);
   if(mem)
      return mem;
   else
     throw bad_alloc();
}

class Foo{ //class operator new
public:
static void* operator new(size_t size);
}

void* Foo::operator new(size_t size){
   cout<<"Foo’s␣own␣operator␣new";
   ....
}

int *p = new int[100]; //output Yan’s own operator new
Foo* fp = new Foo();  //output Foo’s own operator new

Why do I need my own operator new?

Performance: the default memory allocator is designed to be general purpose. Sometimes you have very specific objects you want to allocate, chapter 4 in "Modern C++ Design" presents a very well designed and implemented custom allocator for small objects.
Debugging & statistics: having full control of the way memory is allocated and released provides great flexibility for debugging, statistics and performance analysis.
Customization to cluster related object together, and reduce size. put guard block to avoid overrun and underrun. More detail can be seen in effective c++( third edition) Item 50

Don’t rewrite operator new unless you have to. There are not as easy as you think. such as alignment. First consider some library, such as Boost Pool library for large number small object allocation.

If you have to rewrite operator new, You need to read effective c++( third edition) Item 51 in detail. Such as All operator new should contain a loop calling a new-handling function. should deal with request of zero size. you can see the pseudocode in Item 51.

In C++, after you define a name in a scope (e.g., in a class scope), it will hide the same name in all enclosing scopes (e.g., in base classes or enclosing namespaces), and overloading never happens across scopes. And when said name is operator new, If you provide any class-specific new, provide all of the standard forms(plain, in-place, and nothrow)

class C {
static void* operator new(size_t, MemoryPool&);
// hides three normal forms
};
____________________________________//1) plain new
void* operator new(std::size_t);
____________________________________//2) nothrow new
void* operator new(std::size_t, std::nothrow_t) throw();
____________________________________//3) inplace new
void* operator new(std::size_t, void*);

Always provide new and delete together, see "C++ coding standards" item 45 and 46.

1.1.3.3 Inside of new