"Unsterbliche" Klassen

[Neutral General]

Delphi-Quellcode:

unit Unverwundbar;

interface

uses Classes, Sysutils;

procedure FreeAndNil(var Obj);
// Für das FreeAndNil darf in der Unit wo das Projekt eingebunden ist
// kein Sysutils eingebunden sein damit mein FreeAndNil benutzt wird :mrgreen:

type
 TUnverwundbar = class;
 
 TUnvThread = class(TThread)
 private
  procedure MakeUnv;
 public
  Parent: TUnverwundbar;
 protected
  procedure Execute; override;
 end;

TUnverwundbar = class(TObject)
 private
  Seele: TUnvThread;
 public
  TestString: String;
  constructor Create;
  destructor Destroy; override;
  procedure FreeInstance; override;
 end;

implementation

uses UnvDemo;

{ TUnverwundbar }

constructor TUnverwundbar.Create;
begin
 inherited Create;
 Seele := TUnvThread.Create(true);
 Seele.Parent := Self;
 Seele.Resume;
end;

destructor TUnverwundbar.Destroy;
begin

end;

procedure TUnverwundbar.FreeInstance;
begin

end;

procedure FreeAndNil(var Obj);
begin

end;

{ TUnvThread }

procedure TUnvThread.Execute;
begin
  while not Terminated do
  begin
   Synchronize(MakeUnv);
  end;
end;

procedure TUnvThread.MakeUnv;
begin
 if Self.Parent = nil then begin
  Self.Parent := TUnverwundBar.Create; // Das klappt kein bisschen xD
 end;   // außerdem wäre das auch nur demo weil der string und die Propertys ja die alten sein müssten^^
end;
end.

Also bis jetzt ist meine Klasse fast un-unverwundbar...
Also wer mir helfen kann/will der kann das gerne tun ^^
Auch wenn jetzt meine geniale FreeAndNil-Abwehr geplatzt ist
Obwohl ich die ja nicht mehr nötig hätte wenn ich Klasse := nil umgehen könnte....

[Dax]

Zitat von MaBuSE:

Dann kann ich selbst ausprobieren, ob TObject(Klasse).Free; funktioniert.

Ich füchte das wird nix Free ruft Destroy auf, Destroy ruft FreeInstance auf, und FreeInstance ist nun mal virtuell und damit nur über patchen wieder auf TObject zurückbiegbar.

Edit: So, killen wir die Klasse mal.FreeMem(Pointer(Unverwundbar), Unverwundbar.InstanceSize);

[ichbins]

Zitat von Neutral General:

Delphi-Quellcode:

// Für das FreeAndNil darf in der Unit wo das Projekt eingebunden ist
// kein Sysutils eingebunden sein damit mein FreeAndNil benutzt wird :mrgreen:

das is ja aber auch ein Witz...

[Neutral General]

Zitat von Dax:

Zitat von MaBuSE:

Dann kann ich selbst ausprobieren, ob TObject(Klasse).Free; funktioniert.

Ich füchte das wird nix Free ruft Destroy auf, Destroy ruft FreeInstance auf, und FreeInstance ist nun mal virtuell und damit nur über patchen wieder auf TObject zurückbiegbar.

Edit: So, killen wir die Klasse mal.FreeMem(Pointer(Unverwundbar), Unverwundbar.InstanceSize);

Hehe

Delphi-Quellcode:

var Unv : TUnverwundbar
FreeMem(Pointer(Unv), TUnverwundbar.InstanceSize);

Das bringt nix

[Dax]

Hm, stimmt sogar.

Delphi-Quellcode:

var Unv : TUnverwundbar;
Unv.CleanupInstance;
FreeMem(Pointer(Unv), TUnverwundbar.InstanceSize);

Sollte aber eventuell gehen.. Oder?

[Neutral General]

eh jain... also beim ersten klick nicht aber beim zweiten gibts ne AV...

Aber wie ich festgestellt hab kommt die AV nicht wegen der Klasse.. Denn die funktioniert danach noch einwandfrei
Cleanupinstance setzt die Klasse soweit ich weiß ja nur zurück.

[MaBuSE]

Zitat von Dax:

Delphi-Quellcode:

var Unv : TUnverwundbar;
Unv.CleanupInstance;
FreeMem(Pointer(Unv), TUnverwundbar.InstanceSize);

Sollte aber eventuell gehen.. Oder?

Mach es doch so, das funktioniert auf jeden Fall. (getestet)

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var x : TUnverwundbar;
begin
  x := TUnverwundbar.Create;
  x.TestString := 'Test';

  x.CleanupInstance;       // Aufräumen
  SysFreeMem(Pointer(x));  // und aus Speicher entfernen

  Caption := x.TestString;
end;

Ein paar Worte dazu:
Wenn ein (obj as TObject).Free aufgerufen wird,
wird Destroy, _ClassDestroy, FreeInstance aufgerufen.
in FreeInstance wird dann CleanupInstance und
MemoryManager.FreeMem (der auf SysFreeMem zeigt) aufgerufen.

Obiges Beispiel macht also genau das selbe wie x.Free sollte

Hier noch mal ein Auszug aus der System.pas zum Nachlesen und verstehen:
(Anmerkung: in der system.pas sind manche Proueduren und Funktionen mit dem beginnenden Unterstrich (z.B. _ClassDestroy). Diese Funktionen benutzen die "CompilerMagic". Das bedeutet, das teile der Funktionalität fest im Compiler eingebaut sind. Nach dem "Destroy" eines Objektes wird immer _ClassDestroy aufgerufen, obwohl das in der System.pas gar nicht programmiert ist. Das baut der Compiler von sich aus ein It's magic, compiler magic.)

Delphi-Quellcode:

{*******************************************************}
{       Borland Delphi Runtime Library                  }
{       System Unit                                     }
{       Copyright (C) 1988,99 Inprise Corporation       }
{*******************************************************}
unit System; { Predefined constants, types, procedures, }
...
interface
...
type
...
  TObject = class
    ...
    procedure Free;
    procedure CleanupInstance;
    ...
    procedure FreeInstance; virtual;
    destructor Destroy; virtual;
  end;
...
  PMemoryManager = ^TMemoryManager;
  TMemoryManager = record
    GetMem: function(Size: Integer): Pointer;
    FreeMem: function(P: Pointer): Integer;
    ReallocMem: function(P: Pointer; Size: Integer): Pointer;
  end;
...
{ Procedures and functions that need compiler magic }
procedure _ClassDestroy(Instance: TObject);
function _FreeMem(P: Pointer): Integer;
...
implementation
...
procedure TObject.Free;
begin
  if Self <> nil then
    Destroy;  // Free ruft Destroy auf
end;
...
destructor TObject.Destroy;
begin
  // Destroy ist leer :shock:
  // Es wird aber dann automatisch _ClassDestroy(self) aufgerufen
end;
..
procedure _ClassDestroy(Instance: TObject);
begin
  Instance.FreeInstance; // aha, hier also ;-) !!!
end;
...
procedure TObject.FreeInstance;
begin
  CleanupInstance;  // Räumt auf
  _FreeMem(Self);   // Entfernt Objekt aus dem Speicher
end;
...
procedure TObject.CleanupInstance;
var
  ClassPtr: TClass;
  InitTable: Pointer;
begin
  ClassPtr := ClassType;
  InitTable := PPointer(Integer(ClassPtr) + vmtInitTable)^;
  while (ClassPtr <> nil) and (InitTable <> nil) do
  begin
    _FinalizeRecord(Self, InitTable);
    ClassPtr := ClassPtr.ClassParent;
    if ClassPtr <> nil then
      InitTable := PPointer(Integer(ClassPtr) + vmtInitTable)^;
  end;
end;
...
function _FreeMem(P: Pointer): Integer;
begin
  if P <> nil then
  begin
    Result := MemoryManager.FreeMem(P); // Aha, also der Memorymanager !!!
    if Result <> 0 then
      Error(reInvalidPtr);
  end
  else
    Result := 0;
end;
...
var
  MemoryManager: TMemoryManager = (
    GetMem: SysGetMem;
    FreeMem: SysFreeMem; // Der MemoryManager benutzt per Default SysFreeMem
    ReallocMem: SysReallocMem);
...
function SysFreeMem(P: Pointer): Integer;
begin
  __free(P); // ist extern definiert
  Result := 0;
end;
...
end;

[Neutral General]

Mist -.-^^
Ich programmier ne eigene OOP Programmiersprache ("Michi" (an "Pascal" angelehnt^^)) und da gibts dann unverwundbare Klassen

[Neotracer64]

Hook doch alle gefährlichen Funktionen.

[Neutral General]

Hab ich ja versucht aber was willst du z.B gegen

Klasse := nil; machen ?