Objekt TList- ich versteh kein Wort!

[ark4869]

Hi - ich mal wieder
Nachdem wir das alles im unterricht besprochen haben(und durch eure Hilfe ) hab ich die delphiinterne TList ganz gut verstanden.
Jetzt sollen wir mtihilfe einer besonderen Klasse Liste (wir nennen sie "NRW LIst) das nochmal machen. Diese Basiert nicht auf indizes oder Arrays.
Das problem hierbei ist aber, dass ich seit geraumer Zeit die Programme nicht mehr zum Laufen kriege, schon TList hat nicht recht funktioniert, mal klappte es mal nicht ohne dass was geändert wurde.
Und das hab ich nun auch wieder mit der neuen Klasse. Erzeugen (scheint) jetzt richtig zu funktionieren(zumindestens Erzeugen am Anfang der Reihe), aber sonst nichts, und auch mein Lehrer hat (zumindest bei der alten Liste) keine Fehler entdeckt. Wahrscheinlich ist es was ganz einfaches, aber wir finden den Fehler einfach nicht.
Vllt. findet ja jemand einen Fehler, ohne das Programm vorliegen zu haben. Hier die neue Klasse und das aktuelle Hauptprogramm.

Klasse(daran sollen wir nichts ändern- bei anderen funktionierts aber- detailliert besprochen haben wir DIESE Programmierungn nicht, nur, was diese Klasse allgemein macht: mit einem Zeiger arbeiten):

Delphi-Quellcode:

unit mTList;
{ Version vom 07.11.2008 }
{ Die Klassendefinition entspricht den Vorgaben zu "TList" aus:
  "Materialien zu den zentralen Abiturprüfungen im Fach Informatik
   objektorientierter Ansatz, Delphi" NRW 2008, Seite 10: "Dokumentation
   der Klasse TList"
   Die Liste ist doppelt verkettet mit einem Dummy-Element vor und einem
   Dummy-Element hinter der Liste. }

interface

uses STDCtrls, SysUtils, Forms;

Type TListNode = class (TObject)
private
  zItem: TObject;
  zPrevious, zNext: TListNode;
protected
  constructor Create(Item: TObject; Previous, Next: TListNode); virtual;
  destructor Destroy; virtual;
  procedure SetNext (Next: TListNode);
  procedure SetPrevious (Previous: TListNode);
  procedure SetItem (Item: TObject);
  function GetPrevious: TListNode;
  function GetNext: TListNode;
  function GetItem: TObject;
public
  // TListNode ist eine Hilfsklasse für die in dieser UNIT deklarierten Klasse
  // TList. Daher werden keine öffentlichen Methoden angeboten!
end;

Type TList = class (TObject)
private
  zCurrent, zDummyVorne, zDummyHinten: TListNode;
public
  constructor Create; virtual;
  function IsEmpty: boolean; virtual;
  function IsInFrontOf: boolean; virtual;
  function IsBehind: boolean; virtual;
  procedure Next; virtual;
  procedure Previous; virtual;
  procedure ToFirst; virtual;
  procedure ToLast; virtual;
  function GetItem: TObject; virtual;
  procedure Replace (pObject: TObject); virtual;
  procedure InsertInFrontOf(pObject: TObject); virtual;
  procedure InsertBehind (pObject: TObject); virtual;
  procedure Remove; virtual;
  procedure AddList(pList: TList);
  destructor Destroy; virtual;
end;

implementation

{ ------------------------ TListNode ---------------------------------------- }

  constructor TListNode.Create(Item: TObject; Previous, Next: TListNode);
  begin
    inherited Create;
    zItem:= Item;
    zPrevious:= Previous;
    zNext:= Next;
  end;

  destructor TListNode.Destroy;
  begin
    zItem:= nil;
    zPrevious:= nil;
    zNext:= nil;
    inherited Destroy;
  end;


  
  function TListNode.GetItem: TObject;
  begin
    result:= zItem;
  end;

  procedure TListNode.SetItem(Item: TObject);
  begin
    zItem:= Item;
  end;

  function TListNode.GetPrevious;
  begin
    result:= zPrevious;
  end;

  procedure TListNode.SetPrevious(Previous: TListNode);
  begin
    zPrevious:= Previous;
  end;

  function TListNode.GetNext;
  begin
    result:= zNext;
  end;

  procedure TListNode.SetNext(Next: TListNode);
  begin
    zNext:= Next;
  end;

{ ------------------------------------ TList ------------------------------- }

  constructor TList.Create;
  begin
    inherited Create;
    zDummyVorne:= TListNode.Create(nil, nil, nil);
    zDummyHinten:= TListNode.Create(nil, zDummyVorne, nil);
    zDummyVorne.SetNext(zDummyHinten);
    zCurrent:= zDummyVorne;
  end;

  function TList.IsEmpty: boolean;
  begin
    result:= zDummyVorne.zNext = zDummyHinten;
  end;

  function TList.IsInFrontOf: boolean;
  begin
    result:= zCurrent = zDummyVorne;
  end;

  function TList.IsBehind: boolean;
  begin
    result:= zCurrent = zDummyHinten;
  end;

  procedure TList.Next;
  begin
    if not IsBehind then zCurrent:= zCurrent.GetNext;
  end;

  procedure TList.Previous;
  begin
    if not IsInFrontOf then zCurrent:= zCurrent.GetPrevious;
  end;

  procedure TList.ToFirst;
  begin
    zCurrent:= zDummyVorne.zNext;
  end;

  
  procedure TList.ToLast;
  begin
    zCurrent:= zDummyHinten.zPrevious;
  end;

  function TList.GetItem: TObject;
  begin
    result:= zCurrent.GetItem;
  end;

  procedure TList.Replace(pObject: TObject);
  begin
    if not (IsBehind or IsInFrontOf)
       then zCurrent.SetItem(pObject);
  end;

  procedure TList.InsertInFrontOf(pObject: TObject);
  var new: TListNode;
  begin
    if not IsInFrontOf
    then begin
           new:= TListNode.Create(pObject, zCurrent.zPrevious, zCurrent);
           zCurrent.zPrevious.zNext:= new;
           zCurrent.zPrevious:= new;
         end;
  end;

  procedure TList.InsertBehind(pObject: TObject);
  var new: TListNode;
  begin
    if not IsBehind
    then begin
           new:= TListNode.Create(pObject, zCurrent, zCurrent.zNext);
           zCurrent.zNext.zPrevious:= new;
           zCurrent.zNext:= new;
         end;
  end;

  procedure TList.Remove;
  var help: TListNode;
  begin
    if not (IsInFrontOf or IsBehind)
    then begin
           help:= zCurrent;
           zCurrent.zPrevious.SetNext(zCurrent.zNext);
           zCurrent.zNext.SetPrevious(zCurrent.zPrevious);
           zCurrent:= help.zNext;
           help.Destroy;
         end;
  end;

  procedure TList.AddList(pList: TList);
  begin
    (*** ist noch zu implementieren !!! ***)
  end;

  destructor TList.Destroy;
  begin
    ToFirst;
    while not IsEmpty do remove;
    zDummyVorne.Destroy;
    zDummyHinten.Destroy;
    inherited Destroy;
  end;


end.

Hier das Hauptprogramm:

Delphi-Quellcode:

unit mBewegteUhr;
{Übung 14.3 - Modifikation: West; Uhr2a --> BewegteUhr: September/Oktober 2008} 

interface

uses 
  Windows, Messages, SysUtils, Graphics, Controls, Forms, Dialogs, StdCtrls, 
  classes,
  mTBewegteUhr, mTList;  {TBewegteUhr, TList}

type 
  TMain = class(TForm)
    BtErzeugAn: TButton;
    BtVernAn: TButton;
    BtErzeugEn: TButton;
    BtVernEn: TButton;


    procedure BtVernAnClick(Sender: TObject);
    procedure BtErzeugAnClick(Sender: TObject);
    procedure BtErzeugEnClick(Sender: TObject);
   // procedure FormClose(Sender: TObject; var Action: TCloseAction);
    //procedure BtVernAnClick(Sender: TObject);
    //procedure BtVernEnClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    


  private
    Uhr: TBewegteUhr;
    Liste : TList;
  public

    { Public-Deklarationen }
  end; 

var 
  Main: TMain;

implementation 

{$R *.DFM} 


procedure TMain.BtErzeugAnClick(Sender: TObject);
begin
  Uhr:=TBewegteUhr.Create (Main.Width div 2, Main.Height div 2, 75) ;
  Uhr.Kennt(Main);
  Uhr.Zeigen;
  Liste.ToFirst;
  Liste.InsertInFrontOf(Uhr);


end;

procedure TMain.BtVernAnClick(Sender: TObject);
begin
  if Liste.IsEmpty = false
  then
    begin
      Liste.ToFirst;
      TBewegteUhr(Liste.GetItem).Destroy;
      Liste.Remove;
    end;

  {i := Liste.Count - 1  ;
  if i>=0 then
    begin
      TBewegteUhr( Liste.Items[ i ] ).Destroy;
      Liste.Delete( i );
    end;
  Main.Caption:= IntToStr(Liste.count); }
end;

procedure TMain.BtErzeugEnClick(Sender: TObject);
begin
  Uhr:=TBewegteUhr.Create (Main.Width div 2, Main.Height div 2, 75) ;
  Uhr.Kennt(Main);
  Uhr.Zeigen;
  Liste.ToLast;
  Liste.InsertBehind(Uhr);



end;

{procedure TMain.BtVernEnClick(Sender: TObject);
var i: integer;
begin
  i := Liste.Count - 1  ;
  if i>=0 then
    begin
      TBewegteUhr( Liste.Items[ i ] ).Destroy;
      Liste.Delete( i );
    end;
  Main.Caption:= IntToStr(Liste.count);
end;       }




{procedure TMain.FormClose(Sender: TObject; var Action: TCloseAction);
begin 
  BtVernichtenClick(Sender); 
end; }

procedure TMain.FormCreate(Sender: TObject); 
begin 
  doublebuffered:= true; 
  randomize;
  Liste:= TList.create;
end;





end.

Hoffe ihr könnt mir helfen