Objeto global a la aplicación

[[Al González]]

Empezado por noob

...¿Es esto posible?

Sí. Un buen ejemplo de lo que buscas lo tiene la propia VCL en la unidad Menus.pas:

Código Delphi [-]
unit Menus;

...

interface

...

var
  PopupList: TPopupList;

...

implementation

...

// esto se ejecuta al arrancar el programa
initialization
  ...
  PopupList := TPopupList.Create;
  ...

// esto se ejecuta cuando finaliza el programa
finalization
  ...
  PopupList.Free;
  ...
  
end.

(encontrado con Find in Files en Delphi 7)

Observa cómo la unidad ActnPopup.pas hace uso del objeto global:

Código Delphi [-]
unit ActnPopup;

interface

{ Borland agrega la unidad Menus en esta cláusula Uses porque esta sección
  "Interface" requiere elementos de Menus.pas }
uses Classes, Controls, Menus, ActnMenus, XPActnCtrls, ActnMan, ActnList;

...

implementation

{ Pero en este Uses estaría agregada la unidad Menus sí únicamente se
  quisiera acceder a la variable PopupList }
uses SysUtils, Windows, Messages, Forms;

...

procedure TCustomActionPopupMenuEx.ExecAction(Action: TContainedAction);
begin
  PostMessage(PopupList.Window, WM_COMMAND, TMenuItem(FSelectedItem.Tag).Command, 0);
end;

...

end.

(encontrado con Find in Files en Delphi 7)

Espero te sirva, no dejes de comentarnos.

Al González

[noob]

Perdona mi ignorancia pero, ¿cómo puedo adaptarlo a mi programa?

Supongamos que tengo un formulario y dos clases: Form1, cClase2, cClase3.

Form1:

Código Delphi [-]
unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    Button1: TButton;
    Edit1: TEdit;
    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
  Clase2: cClase2;
begin
  Clase2 := cClase2.Create;
  Clase2.anadir(Edit1.Text);
end;

end.

Unit2:

Código Delphi [-]
unit Unit2;

interface

type
  cClase2 = class
              private
              public
                procedure anadir(Mensaje: string);
            end;

implementation

uses Unit3;

procedure cClase2.anadir(Mensaje: string);
begin
  with Clase3 do
    Contenido := Contenido + Mensaje;
end;

end.

Unit3:

Código Delphi [-]
unit Unit3;

interface

type
  cClase3 = class
              private
              public
                Contenido: string;
            end;

var
  Clase3: cClase3;

implementation

end.

Lo que yo quiero es crear el objeto de la clase cClase3 nada más inicializarse la aplicación para que luego cuando pulse al botón el objeto ya esté creado (como he dicho al principio prescindiendo de un módulo de datos).

[[Al González]]

Empezado por noob

Perdona mi ignorancia pero, ¿cómo puedo adaptarlo a mi programa?

Supongamos que tengo un formulario y dos clases: Form1, cClase2, cClase3...

Parece que sólo te faltaría agregar las secciones de inicialización y finalización en la unidad Unit3, que sería como la unidad Menus.pas del ejemplo que te di.

[noob]

Lo tengo y funciona, muchas gracias.

Form1:

Código Delphi [-]
unit Unit1;

interface

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

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

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  Clase2 := cClase2.Create;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  Clase2.anadir(Edit1.Text);
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  Clase2.mostrar;
end;

end.

Unit2:

Código Delphi [-]
unit Unit2;

interface

type
  cClase2 = class
              private
              public
                procedure anadir(Mensaje: string);
                procedure mostrar;
            end;

implementation

uses Unit3, Dialogs;

procedure cClase2.anadir(Mensaje: string);
begin
  with Clase3 do
    Contenido := Contenido + Mensaje;
end;

procedure cClase2.mostrar;
begin
  ShowMessage(Clase3.Contenido);
end;

end.

Unit3:

Código Delphi [-]
unit Unit3;

interface

type
  cClase3 = class
              private
              public
                Contenido: string;
            end;

var
  Clase3: cClase3;

implementation

initialization

  Clase3 := cClase3.Create;

finalization

  Clase3.Free;

end.

[[Al González]]

Empezado por noob

Lo tengo y funciona, muchas gracias.

De nada Noob, gracias a ti por hacer buenas preguntas. Así es como los foros de Club Delphi se han convertido en un deslumbrante acervo de información técnica.

Por cierto, te recomiendo usar Free en lugar de Destroy, por las razones que se explican en varios hilos que hablan de ello.

Un saludo.

Al.

[noob]

A veces pienso que mis preguntas son un tanto rebuscadas.

Empezado por Al González

Por cierto, te recomiendo usar Free en lugar de Destroy, por las razones que se explican en varios hilos que hablan de ello.

Edito y tomo nota.

[[Delphius]]

Formalmente lo que buscas es un Singleton. Y la forma en llevarlo a cabo es redefiniendo el método de clase NewInstance y el método FreeInstance.

Luego, debes tener una variable que se puede o no, mantener "oculta" que sea del tipo de la clase definida. ¿Para qué? Para que la implementación de NewInstance pueda chequear si existe una instancia de dicha clase, si existe se devuelve dicha instancia, en otro caso se crea.
FreeInstance liberará la instancia.

Más o menos la idea es algo como esto:

Código Delphi [-]
type
TSingleton = class //nuestra clase que será global
  public
    class function NewInstance: TObject; override;
    procedure FreeInstance; override;
end;

implementation

var Instancia: TSingleton; //Nota como esta variable se mantiene "oculta"

class function TSingleton.NewInstance: TObject;
begin
  if (NOT Assigned(Instancia))
     then begin
            Instancia := TSingleton (inherited NewInstance);
            // algo más que deba hacer....
          end;
  result := Instancia;
end;

procedure TSingleton.FreeInstance;
begin
  Instancia := nil;
  inherithed FreeInstance;
end;

Ahora si deseas puedes hacer que se cree y se libere dicha instancia en sus secciones Initialization y Finalization.

Luego puedes tener cuantas variables donde necesites, cuando hagas algo como:

Código Delphi [-]
Variable := TSingleton.Create;

Variable apuntará a "Instancia". Luego si haces,

Código Delphi [-]
Variable.Free;

Liberas al objeto global, es decir a "Instancia".

Se puede modificar un poco el código para no liberar de una, y llevar un contador de las veces que se referencie: NewInstance incrementa el contador, mientras que FreeInstance lo decrementa.

Nomás te cuento esto como alternativa. Hay muchas maneras de implementar un singleton.

La forma que comentó Al es una de ellas. Pero funcionará siempre y cuando usemos la variable que se declara en Interface. Si uno tiene otra variable de la misma clase, puede correr el riesgo de crearla y liberarla, por tanto habrá dos instancias y se rompe el esquema de la variable global (y única).
Ojo, que con el esquema que menciona Al, no hay que liberarla nunca sino dejar que el sistema al finalizar solito se encargue de ello.

Saludos,