Обнаружение утечки памяти и переопределение нового?

Вы можете использовать директивы pragma для сохранения и восстановления нового макроса при отмене определения для перегрузок. См. [MSDN](http://msdn.microsoft.com/en-us/library/hsttss76(VS.71).aspx) для точного синтаксиса.

E.g.

#pragma push_macro("new")
#undef new
void FAR* operator new(size_t cb);
#pragma pop_macro("new") 

Вы можете поместить их в заголовки, например.

begin_new_override.h:

#ifdef new
#define NEW_WAS_DEFINED
#pragma push_macro("new")
#undef new
#endif

end_new_override.h:

#ifdef NEW_WAS_DEFINED
#undef NEW_WAS_DEFINED
#pragma pop_macro("new")
#endif

А потом

#include "begin_new_override.h"
void FAR* operator new(size_t cb);
#include "end_new_override.h"

По моему опыту, переопределение new через #define на уровне препроцессора - плохая идея - вы не только нарушаете перегрузку operator new, но и размещение new, и, возможно, несколько других вещей.

Наличие всех этих макросов FILE и LINE, расширяющихся повсюду, приводит к тому, что ваши разделы .rodata и .data раздуваются строками файлов и номерами строк, и генерирует гораздо больше кода за вызов.

Гораздо лучше (если заранее приложить больше усилий) воспользоваться наличием отладочной информации (например, файл .pdb) и использовать что-то вроде DbgHelp. library/ms680650(VS.85).aspx" rel="nofollow noreferrer">StackWalk64 для сбора информации о стеке.

Перегружайте различные комбинации глобального оператора new и оператора delete (массив, nothrow и т. д.), чтобы они сохраняли и освобождали информацию о стеке по мере выделения и освобождения памяти.

Вы даже можете хранить эту информацию в такой структуре, как std::map‹void *, StackInfo›, просто будьте осторожны, чтобы не записывать аллоки, вызванные вставками карты (глобальная блокировка может быть достаточной для однопоточного приложения, многопоточного приложения). -threaded оставляем читателю в качестве упражнения).

Поскольку вы записываете весь стек для любого заданного распределения, вы можете провести изящный анализ дерева, сгруппировав выделения (утечки или иным образом) по «функциям и потомкам»... И иногда проще отследить сложные утечки, если вы знаете весь стек с момента их выделения.

Вместо того, чтобы определять new как что-то другое, почему бы не перегрузить оператор new?

Добавьте эти определения функций где-нибудь в глобальном пространстве имен:

// operator new overloads
void* operator new( const size_t size, const char* file, int line) throw();
void* operator new( const size_t size, const size_t align, const char* file, int line) throw();
void* operator new[]( const size_t size, const char* file, int line) throw();
void* operator new[]( const size_t size, const size_t align, const char* file, int line) throw();

// can't easily overload operator delete
void operator delete( void* ptr ) throw();
void operator delete[]( void* ptr ) throw();

// matched to the operator new overload above in case of exceptions thrown during allocation
void operator delete( void* ptr, const char* file, int line) throw();
void operator delete[]( void* ptr, const char* file, int line) throw();
void operator delete( void* ptr, const size_t align, const char* file, int line) throw();
void operator delete[]( void* ptr, const size_t align, const char* file, int line) throw();

// global new/delete
void* operator new( size_t size ) throw();
void* operator new( size_t size, const std::nothrow_t& ) throw();
void* operator new( size_t size, size_t align ) throw();
void* operator new( size_t size, size_t align, const std::nothrow_t& ) throw();

void* operator new[]( size_t size ) throw();
void* operator new[]( size_t size, const std::nothrow_t& ) throw();

void operator delete( void* ptr, const std::nothrow_t&) throw();
void operator delete[]( void* ptr, const std::nothrow_t&) throw();

Затем вы можете определить свой собственный новый макрос, который вызывает неглобальные версии, и реализовать глобальные версии, чтобы утверждать или предупреждать, если они вызываются (чтобы поймать что-либо проскальзывающее).

#define MY_NEW(s)    new(s, __FILE__, __LINE__)

Ваши перегрузки на уровне класса будут работать должным образом, если вы вызовете «new» непосредственно в классе. Если вы хотите вызвать MY_NEW для класса, вы можете это сделать, но вам придется переопределить перегрузку в классе, чтобы она соответствовала вашей новой.

Попробуйте #undef new перед определением класса, а затем снова #define new new... после.