Delphi-PRAXiS - Einfaches Listenprogramm mittels Zeigern

Hallo,

ich hatte vor gehabt, ein kleines Beipsielprogramm umzusetzen um das Prinzip der Zeigern und Listen richtig zu verstehen.
Dazu habe ich eine doppelt verkettete lineare Liste benutzt, weil diese besser in dem Programmkontext passt.

Kurzbeschreibung vom Programm

• Der Nutzer gibt den Vornamen und Nachnamen ein
• Diese Informationen werden in einer Liste gespeichert
• Es ist möglich hin und her zu wechseln mittels den Buttons "Vor" und "Weiter"
• Somit kann man vorherige Einträge einsehen

Wenn ich den Programmcode in einer Unit schreibe, dann funktioniert auch alles... Ich habe nur Probleme damit, es eine andere Unit zu transferieren, was ich aber gerne möchte!

Ich hatte wie gesagt vorher alles in der Main-Unit reingeschrieben und bin jetzt dabei es Schritt für Schritt auf die andere Unit auszulagern. Insofern sind noch einige Sachen in der Main.

Delphi-Quellcode:

			unit UMain;

interface

uses

  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,

  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls,

  UTypes, UData;

type

  TForm1 = class(TForm)

    Label1: TLabel;

    Label2: TLabel;

    EdVorname: TEdit;

    EdNachname: TEdit;

    BtnVor: TButton;

    BtnEinfuegen: TButton;

    BtnLoeschen: TButton;

    BtnWeiter: TButton;

    procedure BtnEinfuegenClick(Sender: TObject);

    procedure BtnWeiterClick(Sender: TObject);

    procedure BtnVorClick(Sender: TObject);

    procedure BtnLoeschenClick(Sender: TObject);

    procedure FormClose(Sender: TObject; var Action: TCloseAction);

    procedure FormCreate(Sender: TObject);

  private

    { Private-Deklarationen }

    Current: TElementPointer;

    procedure ShowCurrent;

    function  getInformation:TInfo;

  public

    { Public-Deklarationen }

  end;

var

  Form1: TForm1;

implementation

{$R *.dfm}

{ TForm1 }

procedure TForm1.BtnEinfuegenClick(Sender: TObject);

var TempElement:TElementPointer;

    info:TInfo;

begin

  InsertElement(getInformation); // In UData deklariert

end;

procedure TForm1.BtnVorClick(Sender: TObject);

begin

  if Current^.VorElement <> nil then    // Wenn das vorherige Element NICHT leer ist, dann...

  begin

      Current^.Namen.Vorname  := EdVorname.Text;      // Lese den Namen aus und trage ins EdtFeld ein

      Current^.Namen.Nachname := EdNachname.Text;

      Current := Current^.VorElement;      // Setze den Zeiger auf das vorherige (jetzt aktuelle) Element

      ShowCurrent;        // Zeige die Veränderung

      BtnVor.Enabled:=Current^.VorElement <> nil;

      BtnWeiter.Enabled:=true;

  end

  else ShowMessage('Zugriffsverletzung auf vorderes Element!');

  ActiveControl:=EdVorname;

end;

procedure TForm1.BtnWeiterClick(Sender: TObject);

begin

  if Current^.NachElement <> nil then        // Wenn das nächste Element NICHT leer ist, dann...

  begin

    Current^.Namen.Vorname:=EdVorname.Text;        // Lese den Namen aus und trage ins EdtFeld ein

    Current^.Namen.Nachname:=EdNachname.Text;

    Current := Current^.NachElement;   // Setze Zeiger auf aktuellem Element

    ShowCurrent; // Zeige Veränderungen

    BtnWeiter.Enabled:= Current^.NachElement <> nil;

    BtnVor.Enabled:=true;

  end

  else showMessage('Zugriffsverletzung auf nachfolgende Element!');

  ActiveControl := EdVorname;

end;

function TForm1.getInformation: TInfo;

begin

  getInformation.Vorname:=EdVorname.Text;

  getInformation.Nachname:=EdNachname.Text;

end;

procedure TForm1.ShowCurrent;

begin

  EdVorname.Text:=Current^.Namen.Vorname;

  EdNachname.Text:=Current^.Namen.Nachname;

end;

end.

Ich habe hier einige Prozeduren, welche hier nicht relevant sind (OnCreate) einfach weggelassen, um es übersichtlicher zu gestalten...

Delphi-Quellcode:

			unit UData;

interface

uses SysUtils, UTypes;

function  NewElement(info:TInfo): TElementPointer;

procedure InsertElement(info:TInfo);

procedure getNext;

procedure getPrevious;

implementation

var Current:TElementPointer;

{----------------------------- NewElement -----------------------------------}

function NewElement(info:TInfo): TElementPointer;

var

  TempElement:TElementPointer;

begin

  New(TempElement);

  TempElement^.Namen.Vorname:= info.Vorname;

  TempElement^.Namen.Nachname:= info.Nachname;

  TempElement^.VorElement:=nil;

  TempElement^.NachElement:=nil;

  NewElement:=TempElement;

end;

{----------------------------- InsertElement ---------------------------------}

procedure InsertElement(info:TInfo);

var TempElement:TElementPointer;

begin

  TempElement:=NewElement(info);

  if Current<>nil then

  begin

    TempElement^.NachElement:=Current;

    TempElement^.VorElement :=Current^.VorElement;

    Current^.VorElement:=TempElement;

    if TempElement^.VorElement<>nil then

       TempElement^.VorElement^.NachElement := TempElement;

  end;

  Current:=TempElement;

end;

{----------------------------- getNext ---------------------------------------}

procedure getNext;

begin

// Code

end;

{----------------------------- getPrevious -----------------------------------}

procedure getPrevious;

begin

// Code

end;

end.

Delphi-Quellcode:

			unit UTypes;

interface

type

  TInfo = record

            Vorname: string[30];

            Nachname: string[30];

          end;

  TElementPointer = ^TListElement;

  TListElement =  record

                      Namen: TInfo;

                      VorElement : TElementPointer;

                      NachElement: TElementPointer;

                  end;

implementation

end.

Problembeschreibung vom Programm

Ich kann völlig normal auf Einfügen klicken und die Prozedur InsertElement ausführen, womit ich ein neues Listenelement erzeuge und darin die Informationen aus den Editfeldern reinschreibe. Wenn ich nun aber zurückblättern möchte (oder vor) kommt die Exception "EAccessViolation". Wahrscheinlich ist die Lösung sehr einfach, allerdings kann ich es mir nicht erklären, weil ja eigentlich die Listenelemente exisitieren...