Entender las excepciones y Eurekalog?
 

Que tal Colegas, vengo intentando aprender a depurar con EUREKaLog.

Tenía errores de INVALID POINTER OPERATION, y leyendo en los foros encontré que se debía en su mayor parte a como se crean los forma.

Siempre los creé de a siguiente forma (cortando del DPR los que no quiero en autocreate)

Código Delphi [-]
 Application.CreateForm(TForm1, Form1)

Entonces cambié todas esas creaciones por

Código Delphi [-]
Form1 := TForm1.Create(nil);

Todo bien hasta que se me dio por probar pasar eurekalog

Y resulta que me da que tengo 10 fugas.

Y si no entiendo mal entre todo lo que figura me indica todos los CREATE.NIL

Les adjunto un txt con el reporte de leaks.

Y quisiera que me orienten, para ver si entiendo bien.

En el LEAK1 todo lo que aparece en units propias de la vcl no son leaks no?
Sólo lo que figura en units y forma creadas por mi verdad?.

Como por ej en el leak1 figura la siguiente, que es donde hay un create.nil

|00000002|04 |00000000|00D29311|TuSiVenXP.exe|00929311|principal |TFPrincipal |PresupuestosExecute |1414[1]


TXT CON REGISTRO DE LEAKS

Desde ya gracias por el espacio y su tiempo

Hombre, forma correcta de crearlos es como dices, con una particularidad

Si las creas como:

Código Delphi [-]
Form1 := TForm1.Create(Owner);

Es el propio componente propietario el responsable de eliminar el objeto una vez se destruye.

Sin embargo, si la creas así;

Código Delphi [-]
Form1 := TForm1.Create(nil);

Al no tener propietario, no la libera nadie, con lo que ya tienes una fuga de memoria.

La forma correcta de hacerlo siempre es liberándola tú, de esta forma

Código Delphi [-]
Form1 := TForm1.Create(nil);
try
  ...
  ...
finally
  Form1.Free;
end;

Un saludo

Eso quería entender. Muchas Gracias.

Al final en lugar de arreglar, he creado varias fugas, ya que cambié todas las
sentencias

Código Delphi [-]
  Application.CreateForm(TForm1, Form1)

Por

Código Delphi [-]
Create(nil)

pensando que era mejor. Pero así que e caso de usar nil, se usa con Try finnaly.

Si uso CREATE(Owner). Está bien luego en el evento OnClose un

Código Delphi [-]
Action := CaFree;

O se debe usar FreeAndNil que en algunos lados vi que sugieren.

Que diferencia hay con CREATE(Self)?

Cuando creas una instancia de componente, o formulario (los formularios también son componentes), el constructor te permite indicar qué otro componente es el dueño (propietario) de la nueva instancia de objeto. Ese dueño tendrá entonces ese nuevo componente en su lista de componentes adueñados, lista a la que podrás acceder mediante su propiedad Components. De tal suerte que, combinando el uso de esa propiedad con ComponentCount (cantidad de componentes adueñados), podrías realizar algún recorrido por cada uno de ellos, por ejemplo, para automatizar algún cambio sin necesidad de conocer previamente qué componentes son los que hay en la lista. Cuando el componente dueño se destruye, éste se encarga de destruir también la lista de componentes que posee, liberando la memoria de cada uno en orden inverso a su inclusión en la lista Components.

Self es una variable implícita, es decir, no declarada en el código fuente (como es el caso de Result en los métodos function). Self representa al objeto con el que se está ejecutando el método donde está expresada. Es así que Self, dentro de un método como TForm1.Button1Click es el objeto Form1 que, habiéndose instanciado tiempo atrás, ahora está en operación y el usuario ha presionado su botón Button1. Entonces, si dentro de un método de formulario haces algo como

Código Delphi [-]
  MiNuevoObjeto := TClaseComponente.Create (Self);

, esencialmente estás construyendo un nuevo componente (MiNuevoObjeto) e instruyendo al objeto formulario (Self) para que lo incluya en su propiedad Components.

Siendo "muy probable" que tras la ejecución de esa línea, la expresión Boolean

Código Delphi [-]
Components [ComponentCount - 1] = MiNuevoObjeto

sea verdadera. Pero no confíes mucho en esto último pues, dependiendo de cada caso, puede que el constructor de un componente esté programado para desencadenar la creación interna de otros objetos más, incluso con la particularidad de que esos otros objetos sean también componentes y queden bajo la tutela del mismo Owner. Así, MiNuevoObjeto podría quedar realmente en la casilla Components [ComponentCount - 2], Components [ComponentCount - 3], etc.

Abundé en el tema para refrescar un poco la mente, pero que sea de utilidad mi aportación. :-)

Saludos.

Al González.

Muchas Gracias Al Gonzalez, muy completa tu explicación, casi es todo un curso.

Para finalizar la consulta, para cerrar los forms creados ¿basta con Action :Cafree en OnClose? O se deberia hacer freeandNil?

Yo todos los forms los creo con

Código Delphi [-]
Application.CreateForm(TClaseDelForm, aForm);

Ejemplo para un form Modal, usando caFree:

Código Delphi [-]
function ShowFormModal(ClaseFormulario:TFormClass):TmodalResult;
var
  Formulario: TForm;
begin
  Application.CreateForm(ClaseFormulario, Formulario);
  Try
    result:=Formulario.ShowModal;
    //aquí el Formulario ya no existe; no accedas a ninguna de sus propiedades o métodos
  Except
    result:=mrCancel;
    Formulario.Release;
  end
end;

Ejemplo para un form Modal, usando caHide:

Código Delphi [-]
function PedirDatos(var Nombre,Direccion:string):boolean;
var
  Formulario: TFormNombreDireccion;
begin
  Application.CreateForm(TFormNombreDireccion, Formulario);
  Try
    result:=(Formulario.ShowModal=mrOk);
    //aquí el Formulario aún existe; simplemente es invisible
    if result then begin
      Nombre:=Formulario.edtNombre.Text;
      Direccion:=Formulario.edtDireccion.Text;
    end;
  finally
    Formulario.Release;  //Hay que liberarlo sí o sí, porque no se destruirá solo
  end
end;

Ejemplo para un form NO Modal, es mejor que uses caFree; otra cosa es complicarse la vida:

Código Delphi [-]
procedure ShowForm(ClaseFormulario:TFormClass);
var
  Formulario: TForm;
begin
  Application.CreateForm(ClaseFormulario, Formulario);
  Try
    Formulario.Show;
  Except
    Formulario.Release;  //Solo lo destruimos nosotros si da error el Show
    raise;  //Y volvemos a relanzar la excepción
  end
end;

Gracias a todos por sus aportes.

Yo siempre creé los forma así

Código Delphi [-]
Application.CreateForm(ClaseFormulario, Formulario);

Que era como el mismo delphi crea los forms automáticamente.

Pero después leyendo había visto que esa forma acarrea leaks mas facilmente.

No sé de dónde sacas que acarrea leaks más fácilmente; no estoy de acuerdo.
Pero cada uno tenemos nuestras formas preferidas de programar :)

Otra vez con lo mismo
 

Que tal compañeros

Yo sigo sin entender al EUREKLOG.

Me encuentra MEMORY LEAK en la linea de creacion de este reporte de quickreport

Código Delphi [-]
// Application.CreateForm(TReporte.Create, Reporte );    //primero creaba de esta forma, detecta LEAK
  Reporte := TReporte.Create(nil);   // luego lo creo de esta otra forma  LEAK
        try
             Reporte.prepare; 
             Reporte.Qrlabel.Caption := 'TEXTO';
            Reporte.Print;
        finally
           Reporte.Free;
        end;

El leak me lo marca en esa linea de creacion. (size 30)
Pero ademas, me engancha 2 LEAKS mas dentro de las UNITS DE QUICKREPORT (TQRPRINTER size 1572, TQRStream size 76)

Y al final mete otro LEAK asociado a mi exe


|+Leak #4: Type=Data at $0B861110; Total size=24576; Count=1 |
|-----------------------------------------------------------------------------------------------------------------------------------------------|
|00000002|03 |00000000|004C86F7|project.exe|000C86F7|System.Classes |TMemoryStream |Realloc

¿existirán estos leaks?

O serán fantasmas.

Porque en esa sección de impresión nunca tuve errores.

Y con el eureka pretendía optimizar un poco los recursos y que me ayude a testear.
Pero hasta ahora ve errores donde yo no. aunque ojo SUELO ESTAR CORTO DE VISTA.