• Lunes 16 de Diciembre de 2024, 05:53
« anterior próximo »
Páginas: [1]

Autor Tema:  override del operador new  (Leído 1170 veces)

diego.martinez

  • Miembro MUY activo
  • ***
  • Mensajes: 297
    • Ver Perfil
override del operador new
« en: Lunes 25 de Mayo de 2009, 15:59 »
0
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?

Eternal Idol

  • Moderador
  • ******
  • Mensajes: 4696
  • Nacionalidad: ar
    • Ver Perfil
Re: override del operador new
« Respuesta #1 en: Lunes 25 de Mayo de 2009, 16:13 »
0
El operador new no puede tener esos parametros.

Nacional y Popular En mi país la bandera de Eva es inmortal.


Queremos una Argentina socialmente justa, económicamente libre y  políticamente soberana.
¡Perón cumple, Evita dignifica!

La mano invisible del mercado me robo la billetera.

diego.martinez

  • Miembro MUY activo
  • ***
  • Mensajes: 297
    • Ver Perfil
Re: override del operador new
« Respuesta #2 en: Martes 26 de Mayo de 2009, 15:46 »
0
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?
Páginas: [1]
« anterior próximo »