sobrecarga new / delete

Estou fazendo um pequeno localizador de vazamentos de memory no meu programa, mas minha maneira de sobrecarregar new e delete (e também new [] e delete []) não parece fazer nada.

void* operator new (unsigned int size, const char* filename, int line) { void* ptr = new void[size]; memleakfinder.AddTrack(ptr,size,filename,line); return ptr; } 

A maneira que eu sobrecarregado new é mostrada no trecho de código acima. Eu acho que é algo com o operador retornando void *, mas eu não sei o que fazer sobre isso.

 void* ptr = new void[size]; 

Não pode fazer isso. Consertá-lo.

Nunca tente sobrecarregar new / delete globalmente. Ou tê-los em uma class base e derivar todos os seus objects dessa class ou usar um namespace ou um parâmetro de alocador de modelo. Por que, você pode perguntar. Porque no caso do seu programa ser mais do que um único arquivo e usar o STL ou outras bibliotecas, você vai estragar tudo.

Aqui está uma versão destilada do new operador do VS2005 new.cpp :

 void * operator new(size_t size) _THROW1(_STD bad_alloc) { // try to allocate size bytes void *p; while ((p = malloc(size)) == 0) if (_callnewh(size) == 0) { // report no memory static const std::bad_alloc nomem; _RAISE(nomem); } return (p); } 

RÉ:

Nunca tente sobrecarregar novo / excluir globalmente

Por que é sempre que alguém tenta usar um recurso menos comum do C ++, alguém age como se nunca devesse ser feito?

É feito o tempo todo, é bastante comum, e eu não trabalhei para empresa que não fez isso.

Sobrecarga globalmente new e delete são extremamente úteis no rastreamento de memory, bugs de memory, buffer overruns, etc.

Ninguém no seu perfeito juízo vai passar por um programa com vários milhões de linhas de código, e adicionar um novo membro e excluir a cada class. Isso é apenas idiota.

Talvez você possa fazer o que quiser com um pouco de magia pré-processador:

 #include  using namespace std; void* operator new (size_t size, const char* filename, int line) { void* ptr = new char[size]; cout << "size = " << size << " filename = " << filename << " line = " << line << endl; return ptr; } #define new new(__FILE__, __LINE__) int main() { int* x = new int; } 

Eu acho que o problema aqui é que o perfil de parâmetro do seu novo não corresponde ao do operador padrão new, então esse não está sendo escondido (e, portanto, ainda está sendo usado).

Seus perfis de parâmetros para novo e excluir precisam ter esta aparência:

 void* operator new(size_t); void operator delete(void*, size_t); 

Você está invocando o operador sobrecarregado corretamente, isto é, passando os parâmetros adicionais?

O problema depende dos dois argumentos que você adicionou ao novo operador sobrecarregado. Tente tornar o nome do arquivo e a linha global de alguma forma (ou variables ​​de membro se você estiver sobrecarregando o novo e excluindo para uma única class). Isso deve funcionar melhor.