argumentos FormCreate
 

¿Se puede pasar argumentos a este procedimiento tan especial?

La operación tiene esta cabecera:

Código Delphi [-]
procedure FormCreate(Sender: TObject; lista: TLista);

Y la llamo como sigue:

Código Delphi [-]
For:=TFor.Create(For,list);

Para que la asignación de la segunda sentencia que presentás sea válida, la primera debiera tener un constructor y no un método cualquiera. Por ejemplo:

Código Delphi [-]
type
  TFor = class(TForm)
    ...
  public
    constructor Create(AOwner: TComponent; Lista: TList);
...

procedure TMainForm.Button10Click(Sender: TObject);
begin
  For := TFor.Create(Self, Lista);
end;

Esto sería perfectamente válido, solamente tener cuidado de en el constructor de la clase debe llamarse a algún constructor de la clase padre, para que la creación e inicialización de, en este caso, la forma se realice correctamente.

También tener en cuenta que el constructor create declarado en este caso no sustituye al constructor create de la clase TForm, aun cuando tenga el mismo nombre, por lo que por ejemplo, una llamada a Application.CreateForm, seguirá usando el constructor create de TForm y no el create de TFor.

Hasta luego.

;)

Aunque no es fundamental, para que el compilador no nos grite con sus advertencias, yo usaría la directiva reintroduce:

Código Delphi [-]
  TFor = class(TForm)
    ...
  public
    constructor Create(AOwner: TComponent; Lista: TList); reintroduce;

...

Por cierto, con For, esto no va a compilar :p

// Saludos

¡Es cierto!, no había caido en la cuenta de ello.

Probemos...

c/For/AFor

Ok. ahora compilará.. :D

Hasta luego.

;)

:eek: ¿Qué es esto? ¿vi?

// Saludos

ups... :s lo siento:

[alt][s] [r] For [tab] AFor [alt][a] [Intro]

:D

Hasta luego.

;)

Muchas gracias jachguate creo q con tu ejemplo servirá.

¿Para que sirve esa instrucción reintroduce?

He cambiado todas las operaciones que tenía en la operación FormCreate a la nueva operación (q he introducido) Create. El resultado no ha sido el esperado. Se cuelga al ejecutar la operación ShowModal tras crear el formulario.

No sé exactamente como implementar esta idea.

Tiene que ver con la herencia. Sirve para "reintroducir" un método virtual como nuevo. Intentaré aclararlo con un ejemplo (a ver si me sale, que lo estoy haciendo de memorieta):

Código Delphi [-]
TYPE
  TBASE = CLASS (TOBJECT)
  PUBLIC
    PROCEDURE Procedimiento; VIRTUAL;
  END;

  TDERIVADA1 = CLASS (TBASE)
  PUBLIC
    PROCEDURE Procedimiento; OVERRIDE;
  END;

  TDERIVADA2 = CLASS (TBASE)
  PUBLIC
    PROCEDURE Procedimiento; REINTRODUCE;
  END;

Tenemos el método virtual Procedimiento, el cual es heredado por las dos clases derivadas. Una de ellas la implementa de nuevo (OVERRIDE) mientras que la otra la "reintroduce" de forma que tiene dos métodos con el nombre "Procedimiento". No es lo mismo que OVERLOAD, ojo.

La cosa está en lo siguiente:

Código Delphi [-]
PROCEDURE Uso (aObjeto1: TBASE, aObjeto2: TDERIVADA2);
BEGIN
  aObjeto1.Procedimiento;
  aObjeto2.Procedimiento;
END;

VAR
  ElObjeto: TDERIVADA2;
BEGIN
  ElObjeto = TDERIVADA2.Create;
  Uso (ElObjeto, ElObjeto);
  ElObjeto.Free;
END

En la primera línea llamamos al procedimiento virtual de la clase TBASE, que en tiempo de ejecución puede ser tanto la definida para TBASE como la definida para TDERIVADA1.

En la segunda línea llamamos al procedimiento "reintroducido" por la clase TDERIVADA2.

Espero que haya aclarado las cosas en lugar de liarlas más.

Me parece que no has llegado tan dentro como sería necesario para figurarme que puede pasar con esto, así que te recomiendo intentar llegar mas allá, bien lanzando el showmodal con f7 (step into) o bien poniendo breakpoints en el código que debe ejecutarse en el código que se lanza en ese intervalo.

Para demostrar que es posible, he preparado un pequeño ejemplo, espero te sea de utilidad.

Código Delphi [-]
unit Unit2;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Buttons;

type
  TForm2 = class(TForm)
    lDato: TLabel;
    BitBtn1: TBitBtn;
  private
    { Private declarations }
  public
    { Public declarations }
    constructor Create(AOwner: TComponent; Dato: string); reintroduce;
  end;

implementation

{$R *.dfm}

{ TForm2 }

constructor TForm2.Create(AOwner: TComponent; Dato: string);
begin
  inherited Create(AOwner);
  lDato.Caption := Dato;
end;

end.

Código Delphi [-]
unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

uses Unit2;

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var
  f2: TForm2;
begin
  f2 := TForm2.Create(Application, (Sender as TButton).Caption);
  try
    f2.ShowModal;
  finally
    f2.Free;
  end;
end;

end.

El evento OnClick de ambos botones está relacionado al método Button1Click.

Creo que el dfm puede deducirse fácilmente de los .pas. ¿no?

Hasta luego.

;)

Muchas gracias. He conseguido ejecutar tu ejemplo perfectamente, pero no consigo arreglar mi programa. Exactamente me escupe:

Parando la ejecución en la instrucción For.Free (se ejecuta inmediatemente despues del Create y ShowModal).

Creo que el mensaje es claro: Tu ventana ya está visible cuando llamas a ShowModal, y pues esto no tendría sentido.

Evidentemente, es tu propio código el que hace que esta ventana sea visible. Iniciá revisando que el estilo de la forma sea fsNormal, y si es así, pues dar una revisión general de las rutinas que se invocan entre el Create y el ShowModal.

Hasta luego.

;)

No se, me parece q lo voy a tirar todo y empezaré de nuevo, xq el estilo es 'fsnormal' y entre el 'create' y el 'showmodal' no hay ninguna operación (se ejecuta el showmodal inmediatamente despues del create). Muchas gasias de todos modos.

PD: Si omito el 'showmodal' no se muestra el formulario y si lo incluyo peta la ejecución, toy apañao.

Antes de "tirar" todo, verifica la propiedad Visible de tu formulario, si tu ventana no es MDIChild, esta debe tener el valor False.



Saludos...

Si el formulario es MDIChild, no tendría sentido mostrarlo con ShowModal. La propiedad Style del formulario debiera tener fsNormal.

Hasta luego.

;)

Si, pero si por algún motivo cambias la propiedad FormStyle a fsMDIChild, la propiedad Visible cambia a True, pero si regresas la propiedad FormStyle a fsNormal, Visible no cambia su valor...

Así que no está de más que verifique lo que comento... ;)



Saludos...

La propiedad visible sta a False.

He leido rapidamente por encima tu mensaje y creo que tu problema radica en que tienes declarada la form como "autocreada" en la proyecto de delphi. Pulsa CTRL+Mays+F11 y verifica si en el apartado de Auto-create Forms esta este formulario. Si es asi... pasalo al apartado de "available Forms" para que no se cree automaticamente. Doy por sentado que es tu codigo el que crea la form y la muestra modal no ???

Si.

Al final lo he conseguido resolver haciendo una función auxiliar que inicializase los parámetros antes de llamar a Create y he restaurado la operación Create sin parametros que tenia en un primer momento funcionando. Muchas gracias por todas las respuestas.

Perdona pero sigo sin entender la diferencia entre REINTRODUCE y OVERRIDE.

En el ejemplo que pones, se obtiene el mismo resultado si ElObjeto es del tipo TDerivada1 (que hereda con OVERRIDE) o si es TDerivada2 (que hereda con REINTRODUCE), porque siempre se puede hacer casting sobre un "hijo" haciéndolo pasar por su "padre": TClasePadre(TClaseHija).

Tanto con OVERRIDE como con REINTRODUCE se sobre-escribe el código fuente de métodos heredados. Dicha sobre-escritura se realiza dentro del objeto "hijo", sin destruir el código original del padre. El cual, siempre es accesible desde el "hijo" si se hace uso de INHERITED.

La úncia diferencia que conozco es que con OVERRIDE el compilador lanza en ocasiones algunos mensajes de aviso que no son lanzados si se usa REINTRODUCE. Mi gran duda es ¿existe alguna diferencia más aparte de esos mensajes de aviso en la compilación? ¿Acaso REINTRODUCE sólo vale para no hacernos daño a la vista con esos mensajes de compilación? ¿A qué nos arriesgamos exactamente haciendo caso omiso de dichos mensajes?

Muchas gracias.

Pues sí, la verdad es que el ejemplo que puse es muy poco afortunado. :( Intenté simplificarlo y lo simplifiqué tanto que me pasé. Intentaré explicarlo mejor:

Código Delphi [-]
TYPE
  TBASE = CLASS (TOBJECT)
  PUBLIC
    PROCEDURE Procedimiento; VIRTUAL;
  END;
 
  TDERIVADA = CLASS (TBASE)
  PUBLIC
    PROCEDURE Procedimiento; OVERRIDE;
  END;

PROCEDURE Uso (aObjeto: TBASE);
BEGIN
  aObjeto.Procedimiento;
END;
 
VAR
  ElObjeto: TBASE;
BEGIN
  ElObjeto = TDERIVADA.Create;
  ElObjeto.Procedimiento;
  Uso (ElObjeto);
  ElObjeto.Free;
END

En este ejemplo, dentro como fuera del procedimiento Uso se llama al método Procedimiento definido en la clase TDERIVADA. Esto es porque en TDERIVADA existe un único método con el nombre Procedimiento. Si no entiendes porqué, deja de leer y busca una explicación sobre la herencia y programación orientada a objetos.

En otro caso, seguimos con otro ejemplo:

Código Delphi [-]
TYPE
  TBASE = CLASS (TOBJECT)
  PUBLIC
    PROCEDURE Procedimiento; VIRTUAL;
  END;
 
  TDERIVADA = CLASS (TBASE)
  PUBLIC
    PROCEDURE Procedimiento; REINTRODUCE;
  END;

PROCEDURE Uso (aObjeto: TBASE);
BEGIN
  aObjeto.Procedimiento;
END;
 
VAR
  ElObjeto: TBASE;
BEGIN
  ElObjeto = TDERIVADA.Create;
  ElObjeto.Procedimiento;
  Uso (ElObjeto);
  ElObjeto.Free;
END

En este segundo ejemplo, fuera del procedimiento Uso llama al método Procedimiento definido en la clase TDERIVADA mientras que dentro de Uso llama al definido en TBASE a pesar de que el objeto es de clase TDERIVADA. Esto es porque en TDERIVADA existen 2 métodos con el nombre Procedimiento: El heredado de TBASE y el re-definido (es decir, "re-introducido") en TDERIVADA.

Si no entiendes cuándo utilizar REINTRODUCE u OVERRIDE, entonces deberías utilizar siempre OVERRIDE y, si el compilador muestra algún error, estudiar el porqué aparece el error y solucionarlo (sin utilizar REINTRODUCE, se entiende).

[edit]Cambié un poco los ejemplos para que fuera más claro (o eso creo :confused: )

Hola,

Quisiera enfatizar que no se trata de entender la diferencia entre override y reintroduce, sino de entender que son conceptos totalmente disímiles e incluso opuestos.

Los métodos virtuales y la directiva override, es el mecanismo que utiliza Delphi para implementar el polimorfismo. Omitir la directiva override, significa romper el polimorfismo, se define un método con el mismo nombre que el de una clase ancestra pero que no tiene nada que ver con aquél.

Dado que hacer esto- romper el polimorfismo -es algo inusual y poco recomendado, el compilador de Delphi nos lo advierte. La directiva reintroduce no tiene ninguna utilidad excepto la informativa: indica al compilador (y a quien lea el código fuente) que eso- romper el polimorfismo -es nuestra intención, que estamos conscientes de la barbaridad que estamos haciendo, que nuestras razones tenemos para ello y que deje de protestar (el compilador y quien lea el código fuente).

El método reintroducido, ciertamente puede usar inherited, pero ya no puedes llamarlo polimórficamente.

// Saludos

Muchísimas gracias. Ya lo tengo claro. :)

Tal como sospechaba, REINTRODUCE sólo vale para que el compilador no nos "moleste" con mensajes de advertencia de ruptura polimórfica voluntaria.