SoloCodigo

Programación General => C/C++ => Mensaje iniciado por: diego.martinez en Lunes 25 de Mayo de 2009, 15:59

Título: override del operador new
Publicado por: diego.martinez en Lunes 25 de Mayo de 2009, 15:59

Buenas:

estoy probando a hacer override del operador new para hacerme checkeos de memoria y ver si alguna funcion tiene "leaks".

para ello me he hecho:

Código: C++

1.  
2.  
3. #ifdef _MY_MEMORY_CONTROL_OVERRIDE
4.  
5. void* operator new(size_t size)
6. {
7.  void *p=malloc(size);
8.  
9.  if (p!=NULL)
10.  if (IsDebuggerPresent())
11.  {
12.      char s[100];
13.      sprintf(s,"Mem: %08x Size: %07d Total:%dn",p,size,MemControl::APP_GlobalMemoryAllocated);
14.         OutputDebugStringA(s);
15.  
16.      MemControl::APP_GlobalMemoryAllocated+=(unsigned long)size;
17.      MemControl::Add(size,p);
18.  }
19.  
20.  return p;
21. }
22.  
23. #endif
24.  
25.  

asi cada vez que se localiza memoria me lo muestra en el output del debugger.

para que me muestre la linea y fichero, le añado:

Código: C++

1.  
2. void* operator new(size_t size,char *szFile = __FILE__, UINT nLineNo = __LINE__)
3.  
4.  

al hacerlo me muestra los errores :

error C2668: 'operator new' : ambiguous call to overloaded function

por lo visto no sabe diferenciar entre el new de siempre y mi nuevo new, entonces, como puedo forzarle a usar el mio?

Título: Re: override del operador new
Publicado por: Eternal Idol en Lunes 25 de Mayo de 2009, 16:13

El operador new (http://msdn.microsoft.com/en-us/library/t48aek43(VS.71).aspx) no puede tener esos parametros.

Título: Re: override del operador new
Publicado por: diego.martinez en Martes 26 de Mayo de 2009, 15:46

buenas, pues al final lo resolví con lo que yo entiendo que es un parche, pero como solo es una herramienta de debug, me viene bien para la verificación y luego se quita para la release.

os pongo como lo he hecho:

Código: C++

1.  
2.  
3. #ifdef _DEBUG
4.  
5. #include <new>
6.  
7.         void* operator new      (size_t size, const char* file, int line, const char *);
8.         void* operator new[]    (size_t size, const char* file, int line, const char *);
9.         void* operator new      (size_t size);
10.  
11.         #define DEBUG_NEW       new(__FILE__, __LINE__,__FUNCTION__)
12.  
13.         void operator delete    (void * size);
14.         void operator delete    (void * size, const char* file, int line, const char *);
15.         void operator delete[]  (void * size, const char* file, int line, const char *);
16.  
17.     #else
18.        
19.         #define DEBUG_NEW       new    
20.  
21.     #endif
22.  
23.  
24.  
25.  

me defino operadores new con varios argumentos, sin embargo no predefino los argumentos, sino que preparo la macro DEBUG_NEW para llamar a new con los argumentos indicados.
luego , para no tener que cambiar el codigo en el programa:

Código: C++

1.  
2. #include <gMemory.h>
3. #define new      DEBUG_NEW
4.  
5.  

Con lo que mis new se convierten en DEBUG_NEW que es lo mismo que new(__FILE__,__LINE__,__FUNCTION__) con lo que cuando se llama a new, se llama a mi operador new sobrecargado. asi, cada vez que se localiza memoria, lo almaceno en un vector, y cuando se llama a delete, uso el puntero para buscarlo en mi lista y eleminarlo, con lo que al terminar la ejecución , los registros del vector me indican que localización de memoria no se liberó.  :good:

Los operadores delete de mas que defino son necesarios para que el compilador no produzca un error al no encontrar el delete correspondiente, aunque no hace falta, ya que con hacer delete del puntero, ya sabremos que registro del vector es el que se elimina.

Es un poco chapuza, pero da el pego. A mi objeto global MEMORY, le he puesto una variable para evitar la reentrancia al localizar nuevos registros y que no me marque estos como localizaciones de memoria. Me falta añadirle sincronización para multitarea.

que os parece?