Overloaded new not forwarding the details to the required functions...

I don't think you can do that.

If you were to put your #defines at the top of the first file hit by the compiler (i.e. above any include statements) you should get a new global new. But doing that would just lead to other problems, most likely compilation problems.

Think about it; the way you've redefined new is applicable for allocating and only allocating, but new is used for more stuff.
Typically the STL will in some cases use custom new implementations by overloading operator new;

void* operator new[](size_t _Size)
{
 // Some implementation of allocation
}

And in such a scenario, where new is part of method declaration rather than an allocation statement, your #define will yield a compilation error.

Hope this helps,
Fredrik

Thank you for your valuable suggestions.
@JackDingler - STL containers are not calling the default new .They are calling the overloaded ones only but comes out of it without calling heapinfo() which is called in other cases when 'new' is used explicitly by the user. I dont understand why is it happening..

@Fredrik Bornander - You are absolutely right but I have overloaded new[] as well..As i told you earlier everything is working perfectly except for this little thing.
Let me explain the whole thing in detail.
Whenever some STL container calls the overloaded new ,it comes out of it without calling the TrackMemory::heapinfo(stores the pointer to the allocated memory in stack) due to which the stack is not updated with the required information . Whenever the corresponding ‘delete’ is called by the STL container via erase, my code fails to find the pointer to the allocated memory location which needs to be deleted in the stack ,as it was never updated in the stack and it causes my code to show a false memory leak. Therefore if I could somehow ensure that every call to new leads to the calling of Trackmemory::HeapInfo() , the problem will be solved.

any suggestions ? How can I solve this problem?

STL containers do not allocate memory by calling new on the appropriate element types. Instead they allocate memory blocks of arbitrary size, and then call placement new on blocks within that already allocated memory. It works something like this:

if (required_element_number > reserved_element_number) {
   size_t new_element_number = determine_new_reserved_size(required_element_number);
   size_t allocated = allocator->alloc(new_element_number*size_of(element_type);
   for (/*each old element*/) {
      // copy old element to new location using copy constructor and in-place new
      new(/*pointer_to_new_location*/) element_type(/*old_element*/);
   }
   for (/*each new required element*/) {
      // construct new elements using default constructor and placement new
      new(/*pointer_to_memory_location*/) element_type;
   }
}

note that allocator is a template argument that can be passed as an optional argument. I believe the default is calling new on type char, so you may get unexpected calls to new char, rather than calls to new for the element type you actually have. Also note that the in-place calls to new that call the constructors do not assign the result of the new operator and therefore may not fit into the scheme you provided. Also, the two uses of placement new involve both the copy and default constructor of your element type.