1:
2:
3:
4:
5:
6:
7:

TOrdner=record
  name:String;
  Ordner:Array of TOrdner;
  Dateien:Array of String;
  back:POrdner;
end;
POrdner=^TOrdner;                    

1:
2:
3:
4:
5:
6:

TOrdner = class
  name: String; 
  Ordner: TObjectList; // Mit TOrdnern drin 
  Dateien: TStringlist; // bequemer als Array of String, im Prinzip aber dasselbe ;-)
  back: TOrdner; 
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

var List: TObjectList;

//Test ist ein Objekt

//irgendwo
  List.Add(Test);

//irgendwo anders
  List.Delete(List.IndexOf(Test));
  Test.Free;

//alle Objekte durchgehen
var I: Integer;
begin
  for I := 0 to List.Count - 1 do
    MachWas(List[I]);
end;                    

1:
2:
3:
4:
5:
6:
7:
8:

type
  POrdner=^TOrdner;
  TOrdner = class
    name: String;
    Ordner: TObjectList; // Mit TOrdnern drin
    Dateien: TStringlist; // bequemer als Array of String, im Prinzip aber dasselbe ;-)
    back: POrdner;
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

procedure delOrdner(var akt:TOrdner);
var i:Integer;
begin
  For i:=0 to akt.Ordner.Count-1 do
    delOrdner(TOrdner(akt.Ordner[i]));
  akt.Ordner.Free;
  akt.Dateien.Free;
  akt.name:='';
  akt.Free;
end;

procedure newOrdner(var akt:TOrdner;name:String='';last:POrdner=nil);
begin
  akt:=TOrdner.Create;
  akt.name:=name;
  akt.Dateien:=TStringList.Create;
  akt.Ordner:=TObjectlist.Create;
  akt.back:=last;
  if(last<>nil) then last^.Ordner.Add(akt);
end;                    

1:
2:
3:
4:
5:

procedure delOrdner(akt:POrdner);
var i:Integer;
begin
  For i:=0 to akt^.Ordner.Count-1 do
    delOrdner(POrdner(@akt^.Ordner[i]));                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

type
  //POrdner=^TOrdner; -> das ist Unfug! TOrdner ist schon ein Zeiger.
  TOrdner = class
    name: String;
    Ordner: TObjectList; // Mit TOrdnern drin
    Dateien: TStringlist; // bequemer als Array of String, im Prinzip aber dasselbe ;-)
    back: TOrdner; // eigentlich ist eine Rückwärtsverkettung bei dem
                   // Ansatz TObject/TObjectList unnötig; aber wenn schon, dann richtig.
  end;                    

1:
2:
3:

procedure delOrdner(var akt:TOrdner);
//...
procedure newOrdner(var akt:TOrdner;name:String='';last:POrdner=nil);                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

type
  POrdner=^TOrdner;
  TOrdner = class(TObject)
    name: String;
    Ordner: TObjectList; // Mit TOrdnern drin
    Dateien: TStringlist; // bequemer als Array of String, im Prinzip aber dasselbe ;-)
    back: POrdner;

    public
      constructor Create(sname:String='';last:POrdner=nil);
      destructor Destroy; override;
  end;
...
destructor TOrdner.Destroy;
var i:Integer;
begin
  Ordner.Free;
  Dateien.Free;
  name:='';
  inherited Destroy;
end;

constructor TOrdner.Create(sname:String='';last:POrdner=nil);
begin
  inherited Create;
  name:=sname;
  Dateien:=TStringList.Create;
  Ordner:=TObjectlist.Create;
  back:=last;
  if(last<>nil) then last^.Ordner.Add(self);
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

type
  TOrdner = class(TObject)
  private
    FOwner: TOrdner;
    FName: String;
    FOrdner: TObjectList;
    FDateien: TStringList;
  public
    constructor Create(const AName: String = ''; AOwner: TOrdner = NIL);
    destructor Destroy; override;
    property Owner: TOrdner read FOwner;
    property Name: String read FName write FName;
    property Ordner: TObjectList read FOrdner;
    property Dateien: TStringList read FDateien;
  end;

implementation

constructor TOrdner.Create(const AName: String = ''; AOwner: TOrdner = NIL);
begin
  inherited Create;
  FName := AName;
  FOwner := AOwner;
  FOrdner := TObjectlist.Create;
  FDateien := TStringList.Create;
  if Assigned(FOwner) then
    FOwner.Ordner.Add(Self);
end;

destructor TOrdner.Destroy;
begin
  FreeAndNil(FDateien);
  FreeAndNil(FOrdner);
  inherited;
end;                    

1:

UnterOrdner.Owner.Ordner[i].Free;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

destructor TOrdner.Destroy;
var tmp:TOrdner;
begin
  tmp:=FOwner;
  if(tmp<>nil) then begin
    FOwner:=nil;
    tmp.Ordner.Remove(self)
  end else begin
    FreeAndNil(FDateien);
    FreeAndNil(FOrdner);
    inherited;
  end;
end;                    

1:
2:

UnterOrdner.Owner.Ordner.Extract(Unterordner);
UnterOrdner.Free;                    

1:

UnterOrdner.Owner.Ordner.Remove(Unterordner);                    

1:
2:
3:
4:
5:
6:
7:

destructor TOrdner.Destroy;
begin
  If(FOwner<>nil) then FOwner.FOrdner.Extract(self);
  FreeAndNil(FDateien);
  FreeAndNil(FOrdner);
  inherited;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

destructor TOrdner.Destroy;
begin
  FreeAndNil(FDateien);
  FreeAndNil(FOrdner);
  inherited;
end;
...
procedure TOrdner.Free(ARemove:Boolean=false);
begin
  If(self<>nil) then begin
    If ARemove and (FOwner<>nil) then FOwner.FOrdner.Extract(self);
    Destroy;
  end;
end;