Vorteil class function

[Thomas Feichtner]

Hallo Zusammen.

Ich stoße beim durchforsten immer wieder auf class function.
Welche Vorteile/Nachteile hat es wenn man gewisse funktionen als class function ausführt?
Hier ein Beispiel beim Aufrufen einer Form.

Hier ohne Klassenfunktion

Delphi-Quellcode:

unit unit2;

interface

uses Windows, Buttons, Classes, ComCtrls, Controls, Forms, StdCtrls, ExtCtrls;

type
  TMyForm2 = class(TForm)
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;
  
  function ShowMyForm(AOwner: TComponent): TModalResult;

implementation

{$R *.dfm}

function ShowMyForm(AOwner: TComponent): TModalResult;
var
  myForm2: TMyForm2;
begin
  Result := 0;
  try
    myForm := TMyForm2.Create(AOwner);
    Result := myForm.ShowModal;
  finally
    FreeAndNil(myForm);
  end;
end;

und hier mit Klassenfunktion

Delphi-Quellcode:

unit unit1;

interface

uses Windows, Buttons, Classes, ComCtrls, Controls, Forms, StdCtrls, ExtCtrls;

type
  TMyForm = class(TForm)
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
    class function ShowMyForm(AOwner: TComponent): TModalResult;
  end;

implementation

{$R *.dfm}

class function TLsBaseForm.ShowMyForm(AOwner: TComponent): TModalResult;
var
  myForm: TMyForm;
begin
  Result := 0;
  try
    myForm := Self.Create(AOwner);
    Result := myForm.ShowModal;
  finally
    FreeAndNil(myForm);
  end;
end;

Und hier die Unterschiede beim Aufrufen:

Delphi-Quellcode:

procedure TFrom3.Button1Click(Sender: TObject);
begin
  { ohne Klassenfunktion }
  unit2.ShowMyForm(Self);
  { mit Klassenfunktion }
  unit1.TMyFrom.ShowMyForm(Self);
end;

Danke für eure Antworten

[spaxxn]

Wenn du möchtest, dass Formulare nicht zur Erzeugungszeit miterzeugt werden, sondern du sie erst dann erzeugen möchtest, wenn sie auch angezeigt werden, dann realisiert man das so oder zumindest in der Art.

Das dient in erster Linie dazu, den Speicherverbrauch einer Anwendung nicht unnötig aufzublähen.

Edit: Hatte mich verlesen, der Bezug von dem was ich geschrieben habe zu deiner Frage ist gleich null ;)

Auf DSDT gibt es das dazu

[Sherlock]

Zitat:

Zitat von spaxxn

Wenn du möchtest, dass Formulare nicht zur Erzeugungszeit miterzeugt werden, sondern du sie erst dann erzeugen möchtest, wenn sie auch angezeigt werden, dann realisiert man das so oder zumindest in der Art.

Das ist ja im ersten Moment nicht unbedingt ein Grund.

Die zitierte Aussage ergänzt um: "Funktionen die nicht in der Formularklasse definiert sind, sind bereits vor Erzeugung des Formulars verfügbar."

Macht den sinn vielleicht deutlicher.

Edit @Spaxxn: Ja, das hatte ich mir fast gedacht, und versucht zu retten ;)


Sherlock

[taaktaak]

Wenn ich mich da mal einklinken darf:
Das ist doch aber bereits der Fall, wenn die Funktion als Methode im public-Abschnitt genannt wird - oder? Was erreiche ich mit dem Zusatz "class", das verstehe ich nicht...

[Meflin]

Ganz einfach: eine class procedure kannst du auch dann ausführen, wenn die Klasse noch garnicht instanziert wurde!

Beispielsweise kannst du so eine Formklasse erstellen, die sich bei einem Aufruf von .Show selbst instanziert ;)

[taaktaak]

Ah, interessant! Danke für die Auskunft :hi:

[HeinzJ]

Class Member stehen grundsätzlich auch dann zur Verfügung, wenn die Klasse noch nicht instanziert wurde.

[hoika]

Hallo,

du kannst damit sogar Klassen schreiben,
die nur class methods haben,
quasi "globale" Funktionen, die aber trotzdem schön zu einer Klasse gehören.


Heiko

[Thomas Feichtner]

Zitat:

Zitat von hoika

Hallo,
du kannst damit sogar Klassen schreiben,
die nur class methods haben,
quasi "globale" Funktionen, die aber trotzdem schön zu einer Klasse gehören.

Was bringt mir das wenn ich gewisse Funktionen in einer Klasse habe und nicht einfach eine Funktionssammlung in einer Unit?

Also richtigen Vorteil / Nachteil habe ich noch nicht gelesen oder hab ich grad ein Brett vorm Kopf?

[Meflin]

Zitat:

Zitat von Thomas Feichtner

Was bringt mir das wenn ich gewisse Funktionen in einer Klasse habe und nicht einfach eine Funktionssammlung in einer Unit?

Vorteil wäre hier beispielsweise, dass du Namenskonflikte vermeiden kannst - und zwar zwingendermaßen auch für andere Benutzer deiner Unit.

Beispiel: Du hast eine Unit Foo, mit einer Funktion IntToStr ;)

Klar kannst du jetzt über Foo.IntToStr und SysUtils.IntToStr sicherstellen, dass immer die richtige Version verwendet wird. Aber wenn du dein IntToStr zur class function, sagen wir der Klasse TFooUtils machst, dann muss immer TFooUtils.IntToStr verwendet werden...

Abgesehen davon ist "Vorteil" das falsche Wort: du kannst mit class members eben Dinge machen, die ohne nicht gehen... Aber einen "Vorteil" im eigentlichen Sinne gegenüber herkömmlichen members gibt es wohl nicht!

[DeddyH]

Naja, man kann so schöne OOP-Features wie Vererbung nutzen. Mir fallen da spontan meine seligen Java-Zeiten ein, wo man solche Dinge wie Integer.ToString, Float.ToString etc. nutzen konnte.

[Der.Kaktus]

Zitat:

Zitat von DeddyH

Naja, man kann so schöne OOP-Features wie Vererbung nutzen. Mir fallen da spontan meine seligen Java-Zeiten ein, wo man solche Dinge wie Integer.ToString, Float.ToString etc. nutzen konnte.

[OT] Nicht Java..Bitteeeeeeeeeeeeeee[/OT]

[dominikkv]

Bei class function/procedure darf man dann aber nicht auf die Felder der Klasse zugreifen, weil es die ja noch nicht gibt...
Klassenmethoden gehören nicht zur instanz, sondern zur Klasse selber
Klassenmethoden sind zB der constructor (spezielle Form von Klassenmethode), ClassName und InstanceSize, alle von TObject geerbt.

[Thomas Feichtner]

OK, Danke für eure Infos.

Zitat:

Zitat von Meflin

Klar kannst du jetzt über Foo.IntToStr und SysUtils.IntToStr sicherstellen, dass immer die richtige Version verwendet wird. Aber wenn du dein IntToStr zur class function, sagen wir der Klasse TFooUtils machst, dann muss immer TFooUtils.IntToStr verwendet werden...

An so etwas dachte ich schon.

[Apollonius]

Noch ein Vorteil: Du kannst Klassenmethoden ohne den Zusatz "static" auch an abgeleiteten Klassenreferenzen aufrufen. Wenn du beispielsweise TMyDescendantForm von TMyForm erben lässt, kannst du jetzt TMyDescendantForm.ShowMyForm(nil) schreiben und erhältst tatsächlich ein Formular der neuen Klasse.
Statische Klassenmethoden (diese erhalten keinen Self-Parameter) sind nur verkappte Funktionen - sie dienen nur zur Auflösung von Namenskonflikten und besseren Übersichtlichkeit.