Ich habe eine Klasse mit ziemlich vielen Feldern, die ich bei einem Clear alle händisch zurücksetzen müsste.
Da liegt es nahe, einfach im Clear ein Free und danach ein Create zu schreiben.
Das Free klappt auch, aber wenn ich danach Self := TDingsbums.Create schreibe, dann meint der Compiler, "Self" würde nie benutzt.

Spaßeshalber habe ich mal versucht, eine Instanz einfach in einer ihrer Methoden freizugeben und wieder zu erzeugen. Also ungefähr so:

zusammenfalten · markieren

Delphi-Quellcode:

TCorona = class(TObject)
  procedure VirusBeißtZu;
end;

var Corona:TCorona;

...

procedure TCorona.VirusBeißtZu;
begin
  Corona.Free;
  Corona := TCorona.Create;
end;

Zu meinem Erstaunen scheint das zu funktionieren.

Was ist von alledem zu halten?

Es ist eigentlich ganz einfach.

Du hast eine globale Variable, der Du letztlich eine neu erzeugte Instanz zuweist.
Insofern nichts besonderes.

Die Prozedur hast Du allerdings als Methode angelegt.
Insofern muss erst mal eine Instanz erzeugen damit Du die Methode korrekt ausführen kannst.

Du könntest die Methode alternativ als Klassenmethode (class procedure ...) anlegen, damit Du sie immer aufrufen kannst.
Oder Du erzeugst einfach eine ganz normale Prozedur (nicht als Teil einer Klasse), in der Du die neue Instanz erzeugst und zuweist.

Du kannst damit halt immer nur eine globale Variable neu zuweisen.

Du könntest auch eine Prozedur erstellen und eine Variable als var-Parameter übergeben und dieser eine neue Instanz zuweisen.


Da gibt es unterschiedliche Möglichkeiten - ABER ...
... die Klasseneigenschaften einfach in einer Methode "Clear" aufzuräumen ist m.E. der beste Weg.

Die anderen Lösungen empfinde ich als unnötig komplitziert und unübersichtlich. Für das Zurücksetzen von Eigenschaften bietet sich eine Methode Clear oder Init doch nahezu an.

Self ist nur ein interner einfacher Parameter, der keine Referenz auf die externe Variable besitzt, daher ist das so nicht möglich.

markieren

Delphi-Quellcode:

procedure TCorona.VirusBeißtZu(Self: TCorona); // intern ist das Self
begin
  Self.Free;
  Self := TCorona.Create;
end;

//Corona.VirusBeißtZu;
TCorona.VirusBeißtZu(Corona);

Und "leider" ist es nicht möglich die Übergabe zu beeinflussen,
drum ist FreeAndNil auch eine Prozedur und kann micht ebenfalls als Methode implementiert werden, so wie das Free.

Man könnte jetzt in das Speichermanagement eingreifen und nach dem Free das neue Objekt an der "selben" Speicheradresse erzeugen.
Da dann beide Objekte an der selben Stelle liegen, zeigt die externe Variable immernoch auf die "richtige" Stelle.
Bei Multithread kann es aber schief geh.

Dann gäbe es noch die RTTI, mit welcher man alle Felder durchlaufen und freigeben könnte.

Oder man verschiebt die Daten.

zusammenfalten · markieren

Delphi-Quellcode:

type
  TFoo = class(TObject)
    FData: record
      i: Integer;
      S: string;
      A: TArray<Integer>;
    end;
    procedure Clear;
  end;

procedure TFoo.Clear;
begin
  Finalize(FData);
  FillChar(FData, SizeOf(FData), 0); // oder ZeroMemory(@FData, SizeOf(FData)); ... was man halt mag
end;

// oder besser
procedure TFoo.Clear;
begin
  Finalize(FData); // gibt nur den Inhalt frei, z.B. von Strings, aber ohne die Variable selbst zurückzusetzen.
  FillChar(FData, SizeOf(FData), 0);
  Initialize(FData); // Initialisiert nur gemanagte Typen mit 0, also Strings, Variants, dynamische Array, gen. Methoden-Zeiger und IInterface, daher vorher das FillChar/ZeroMemory
end;

bzw.
FinalizeRecord aka FinalizeArray mit Lenght=1
und
InitializeRecord aka InitializeArray mit Lenght=1

Das sind auch die Methoden, welche Delphi benutzt, um globale Variablen, lokale Variablen (das was im BEGIN und END der Methode aufgerufen wird) und den Inahlt von Objekten zu initialisieren und freizugeben.

Moin...
Die eigentliche Frage ist nicht beantwortet...

Zitat:

Was ist von alledem zu halten?

...nichts! Das das funktioniert ist eher Zufall Instanzen die in "Benutzung" sind, Pointer in Listen (die ihre Objekte selbst freigeben), sind sind nicht mehr gültig, weil der Pointer ein anderer und der vorhergehende freigeben ist. Dann dürfte es Zugriffsverletzungen hageln...
Wenn mir ein simpler Vergleich einfällt, lasse ich es euch wissen...

[Offtopic]
Wenn der Baron von Münchhausen eine solche Phönix-Klasse entwickelt, könnte es vielleicht funktionieren, aber im realen Leben ist das eine schlechte Idee.
[/Offtopic]

Anders sieht das aus, wenn das Clear von aussen aufgerufen wird, denn dann kann man auch von aussen stattdessen das Objekt freigeben und neu erstellen.

Zitat von haentschman:

...nichts! Das das funktioniert ist eher Zufall Instanzen die in "Benutzung" sind, Pointer in Listen (die ihre Objekte selbst freigeben), sind sind nicht mehr gültig, weil der Pointer ein anderer und der vorhergehende freigeben ist. Dann dürfte es Zugriffsverletzungen hageln...

Noch schlimmer.
Im NextGen funktioniert es nichtmal, da du das Ojekt garnicht freigeben kannst, so lange noch andere Referenzen existieren,
und selbst wenn man es schafft, würde man dadurch eventuelle Weak-Referenzen schrotten. (auf nil setzen)

Zitat:

im nextgen

pgfnang

Zitat von haentschman:

...nichts! Dass das funktioniert ist eher Zufall

Das dachte ich mir.

Ich habe jetzt unter Clear ein paar Dutzend Objekte händisch erschlagen, aber ich dachte, dass es einen eleganteren Weg gäbe.

Man kann ja ohne Weiteres "von außen" die Instanz freigeben und wieder erzeugen, aber das ist wohl verpönt? Tatsächlich ist bei mir ein Clear auch einige Mikrosekunden schneller als ein Free und Create.

Zitat:

verpöhnt

Wenn das Objekt nur in einer einzigen Varable gespeicher/verlinkt ist, also eine interne Variable wo mögliches niemals jemand Anderes ran kommt, dann mag das schon gehen,
aber sobald jemand anderes eine Referenz auf dieses Objekt besitzt oder zumindestens möglich sein könnte, und es keinen Mechianismus gibt auch diese Referenz zu aktualisieren, war's das.