Objectlist rekursiv free?

[jfheins]

Zitat von moelski:

Gibt es denn überhaupt die Möglichkeit zu Prüfen ob eine Referenz noch auf eine gültige Instanz verweist?
Ich habe schon NIL / Assigend probiert. Das führt aber nicht zum Erfolg.

Du könntest auch noch Interfaces verwenden. Die bringen eine Referenzzählung mit.

oder die Dirty-Variante: Du implementiert ein Boolean-Flag "valid" dass im Konstruktor auf true gesetzt wird. Im Destruktor wird es erst geprüft ob es false ist. Wenn ja => sofort abbrechen. Wenn nein: Auf false setzen und mit den normalen Tätigkeit fortfahren.
Das Vorgehen baut aber darauf, dass in der zwischenzeit keiner den Speicher überschreibt ^^

[Sir Rufo]

Oder du sorgst dafür, dass die Objekte wissen, wo sie überall referenziert werden und dann selber dafür sorgen diese Referenzen zu entfernen.
Kleines Beispiel dafür ist hier mit einem Visitor gelöst.

Zur Vereinfachung habe ich alle möglichen Prüfungen herausgelassen (Ist Item schon SubItem beim hinzufügen oder ist Item überhaupt SubItem beim Entfernen)

Delphi-Quellcode:

unit uObjects;

interface

uses
  Classes, Contnrs;

type
  TMyItem = class
  private
    FSubItems : TObjectList;
    FAnchors : TObjectList;
    // Die Visitor-Routinen
    procedure AddedToItem( Item : TMyItem );
    procedure RemovedFromItem( Item : TMyItem );

  public
    property SubItems : TObjectList read FSubItems;
    property Anchors : TObjectList read FAnchors;
    // Hinzufügen und entfernen nur über diese Routinen
    procedure AddSubItem( Item : TMyItem );
    procedure RemSubItem( Item : TMyItem );

    constructor Create;
    destructor Destroy; override;
  end;

implementation

{ TMyItem }

procedure TMyItem.AddedToItem( Item : TMyItem );
  begin
    FAnchors.Add( Item );
  end;

procedure TMyItem.AddSubItem( Item : TMyItem );
  begin
    FSubItems.Add( Item );
    Item.AddedToItem( Self );
  end;

procedure TMyItem.RemovedFromItem( Item : TMyItem );
  begin
    FAnchors.Remove( Item );
  end;

procedure TMyItem.RemSubItem( Item : TMyItem );
  begin
    FSubItems.Remove( Item );
    Item.RemovedFromItem( Self );
  end;

constructor TMyItem.Create;
  begin
    inherited;
    FSubItems := TObjectList.Create;
    FAnchors := TObjectList.Create;
  end;

destructor TMyItem.Destroy;
  var
    obj : TObject;
  begin

    // Verbindungen lösen wo man SubItem ist
    while FAnchors.Count > 0 do
      begin
        obj := FAnchors[ 0 ];
        if obj is TMyItem then
          TMyItem( obj ).RemSubItem( Self );
      end;

    // Verbindungen zu den SubItems lösen
    while FSubItems.Count > 0 do
      begin
        obj := FSubItems[ 0 ];
        if obj is TMyItem then
          RemSubItem( TMyItem( obj ) );
      end;

    FSubItems.Free;
    FAnchors.Free;
    inherited;
  end;

end.

[stahli]

[etwas OT]
Aber eine Option im Compiler wäre schon schön. Lösbar wäre das sicher.
- Welchem Pointer wurde welche Speicheradresse zugewiesen?
- Welche Adresse wird freigegeben und welche Pointer müssen auf nil gesetzt werden?
(Bei Propertys müsste (sofern vorhanden die private Variable genilt werden.)
Ich kann mir schon viele Fälle denken, in denen das hilfreich wäre.
Der Programmierer müsste sich dann entscheiden, ob er diese Option (und die benötigte Zeit dafür) nutzen will.
Private Visitor-Lösungen funktionieren ja letztlich genau so, nur eben auf eigene Komponenten begrenzt.
[/etwas OT]