Pointer of Array of Pointer neues Prinzip

[Marcel2906]

Nachdem ich mein Programm fertig habe, gab es eine neue Aufgabe:
Nun soll der Record Vorgänger, Wert und Nachfolger enthalten.
Ich füge mal ein jpg ein, dass ich bekommen habe zur Hilfe.

Nun wollte ich erstmal anfangen das eingeben zu Programmieren.
Also die erste Eingabe ist der start record und zeigt auf den 2, der auf den 3 usw.

Also ich hab mir das so gedacht, stimmt das? :

Delphi-Quellcode:

Type
   PEintrag = ^TEintrag;
   TEintrag = Record
      Vorgaenger: PEintrag;
      Wert: integer;
      Nachfolger: PEintrag;
   End;

Type
   TListe = Array Of PEintrag;
   PListe = ^TListe;

Type
   TForm1 = Class(TForm)
      LBOutNumber: TListBox;
      EdGetNumber: TEdit;
      BtBeenden: TButton;
      BtSort: TButton;
      BtHinzufuegen: TButton;
      Procedure FormCreate(Sender: TObject);
      Procedure FormDestroy(Sender: TObject);
   private
      Liste: PListe;
      Eintrag: PEintrag;
      Procedure Input;
      ...
   End;

..

Procedure TForm1.FormCreate(Sender: TObject);
Begin
   Liste := Nil;
   New(Liste);
End;

Procedure TForm1.FormDestroy(Sender: TObject);
Var
   i: integer;
Begin
   For i := Low(Liste^) To High(Liste^) Do
      Dispose(Liste^[i]);
   Dispose(Liste);
End;

Procedure TForm1.Input;
Var
   x, i: integer;
Begin
   // Init mit nichts
   Eintrag := Nil;
   new(Eintrag);
   //neuen Eintrag in Array eintragen
   Eintrag^.Wert := StrToInt(EdGetNumber.Text);
   //Array um 1 erweitern
   SetLength(Liste^, Length(Liste^) + 1);
   //Zahl ans Ende des Arrays eintragen
   x := high(Liste^);
   Liste^[x] := Eintrag;
   //Erste Eintrag hat den Vorgänger Nil
   Liste^[low(Liste^)].Vorgaenger := Nil;
   Liste^[low(Liste^)].Nachfolger := Liste^[(low(Liste^)+1)];
   //Vorgänger und Nachfolger der Einträge festlegen
   For i := (low(Liste^) + 1) To (high(Liste^) - 1) Do Begin
      Liste^[i].Vorgaenger := Liste^[i - 1];
      Liste^[i].Nachfolger := Liste^[i + 1];
   End;
   //Letzte Eintrag hat den NAchfolger Nil
   Liste^[high(Liste^)].Vorgaenger := Liste^[(high(Liste^)-1)];
   Liste^[high(Liste^)].Nachfolger := Nil;
End;

[DeddyH]

Das riecht stark nach doppelt verketteter Liste, dazu gibt es IIRC sogar ein Tutorial hier in der DP.

[edit] Japp, gefunden [/edit]

[Marcel2906]

dann werde ich da mal rein schauen und mich schlau machen :-P

[Marcel2906]

So, nun habe ich mich schlau gemacht, bekomme aber beim schließen meines Programme eine Fehlermeldung "Zugriffsverletzung"..wo liegt mein Fehler:

Delphi-Quellcode:

Type
   PEintrag = ^TEintrag;
   TEintrag = Record
      Vorgaenger: PEintrag;
      Wert: integer;
      Nachfolger: PEintrag;
   End;

Type
   TListe = Array Of PEintrag;
   PListe = ^TListe;

Type
   TForm1 = Class(TForm)
      LBOutNumber: TListBox;
      EdGetNumber: TEdit;
      BtBeenden: TButton;
      BtSort: TButton;
      BtHinzufuegen: TButton;

   private
      Liste: PListe;
      Eintrag: PEintrag;
      Procedure AddElement(Wert: integer);
      Procedure FreeKette;
   End;

Var
   Form1: TForm;
   First: PEintrag; //Anfang der Kette als globale Variable

Implementation
{$R *.dfm}

Procedure TForm1.FormCreate(Sender: TObject);
Begin
   Liste := Nil;
   New(Liste);
End;

Procedure TForm1.FormDestroy(Sender: TObject);
Var
   i: integer;
Begin
   For i := Low(Liste^) To High(Liste^) Do
      Dispose(Liste^[i]);
   Dispose(Liste);
   FreeKette;
End;

Procedure TForm1.BtHinzufuegenClick(Sender: TObject);
Begin
   Try
      AddElement(StrtoInt(EdGetNumber.Text));
      EDGetNumber.Clear;
   Except
      ShowMessage('Nur Zahlen bitte');
      EDGetNumber.Clear;
   End;
End;

Procedure TForm1.AddElement(Wert: integer);
Var
   hlp, hlp2: PEintrag;
Begin
   //Anfang vorhanden ?
   If (FIRST = Nil) Then Begin
      New(First);
      First^.Vorgaenger := Nil; //Der Anfang der Kette hat keinen Vorgänger;
      First^.Nachfolger := Nil; //Der Nachfolger ist auch erstmal nicht vorhanden.
      hlp2 := First;
   End Else Begin
      hlp := First;
      While (hlp^.Nachfolger <> Nil) Do
         hlp := hlp^.Nachfolger;
      new(hlp^.Nachfolger);
      hlp2 := hlp^.Nachfolger;
      hlp2^.Vorgaenger := hlp;
   End;
   hlp^.Wert := Wert;
End;

Procedure tForm1.FreeKette;
Var
   wrk: PEintrag;
Begin
   wrk := First^.Nachfolger;
   While (wrk <> Nil) Do Begin
      Dispose(first);
      first := wrk;
      wrk := wrk^.Nachfolger;
   End;
   Dispose(first);
End;
End.

[DeddyH]

In welcher Zeile denn?

[Marcel2906]

in keiner Zeile..Programm startet normal. Wenn ich dann Zahlen einfüge und mein TForm1 schließe, bekomme ich den Fehler angezeigt

[DeddyH]

Dann stepp doch einmal durch und schau, in welcher Zeile der Fehler auftritt. Übrigens: wozu ist eigentlich das Array gut, das wird doch gar nicht benutzt?

[Marcel2906]

wie gehe ich denn einzeln da durch, habs mit f7 gemacht. und bekomme den fehler erst ganz am ende, wenn das programm schon beendet ist.

Zitat:

Übrigens: wozu ist eigentlich das Array gut, das wird doch gar nicht benutzt?

Später möchte ich die Kette sortieren. Glaube dann brauch ich das array, oder nicht?? ^^

Zitat:

Erste Gelegenheit für Exception bei $7C812AFB. Exception-Klasse EAccessViolation mit Meldung 'Zugriffsverletzung bei Adresse 004ADCFF in Modul 'Pointer.exe'. Lesen von Adresse 00000010'. Prozess Pointer.exe (3264)

[Bummi]

Vielleicht ist der Aufruf von FreeKette im Destruktor nach der Freigabe der Liste keine gute Idee

[Marcel2906]

auch wenn ich freeKette auskommentiere kommt der fehler

[DeddyH]

Die Liste wird ja nicht benutzt, daran liegt es nicht. Ich habe den Code jetzt mal hier unter XE eingefügt und kompiliert, da kommen einige Warnungen und Hinweise, insbesondere in AddElement.

[Marcel2906]

Ahh, habs...also hoffe das ist so richtig..habe new(hlp) hinzugefüht

[DeddyH]

Ich habe AddElement mal umgeschrieben:

Delphi-Quellcode:

Procedure TForm1.AddElement(Wert: integer);
Var
  hlp, neu: PEintrag;
Begin
  // Anfang vorhanden ?
  If (First = Nil) Then
    Begin
      New(First);
      First^.Vorgaenger := Nil; // Der Anfang der Kette hat keinen Vorgänger;
      First^.Nachfolger := Nil; // Der Nachfolger ist auch erstmal nicht vorhanden.
      neu := First;
    End
  Else
    Begin
      hlp := First;
      While (hlp^.Nachfolger <> Nil) Do
        hlp := hlp^.Nachfolger;
      New(neu);
      neu^.Vorgaenger := hlp;
      neu^.Nachfolger := nil;
      hlp^.Nachfolger := neu;
    End;
  neu^.Wert := Wert;
End;

[Bummi]

Delphi-Quellcode:

Procedure TForm1.AddElement(Wert: integer);
Var
   hlp, hlp2: PEintrag;
Begin
   //Anfang vorhanden ?
   If (FIRST = Nil) Then Begin
      New(First);
      First^.Vorgaenger := Nil; //Der Anfang der Kette hat keinen Vorgänger;
      First^.Nachfolger := Nil; //Der Nachfolger ist auch erstmal nicht vorhanden.
      hlp2 := First;
     
   End Else Begin
      hlp := First;
      While (hlp^.Nachfolger <> Nil) Do
         hlp := hlp^.Nachfolger;
      new(hlp^.Nachfolger);
      hlp2 := hlp^.Nachfolger;
      hlp2^.Vorgaenger := hlp;
   End;
   hlp2^.Wert := Wert; 
End;

[DeddyH]

Zu spät :tongue:

[Bummi]

wo ist die rote Box hingekommen .....

[Marcel2906]

danke :))
kann man das ergebnis leicht in eine TListBox eintragen.
Sodass er einfach von vorne nach hinten durchgeht und die Werte einträgt?

[DeddyH]

Ja klar.

[edit] Bei doppelt verketteten Listen macht es auch Sinn, neben First ein Last zu haben, das auf dem letzten Element steht, dann kann man die Liste sowohl von vorn als auch von hinten durchlaufen ;) [/edit]

[Marcel2906]

Wie kann ich denn sagen er soll alles ausgeben bis er zum letzten kommt.
Ich habs so probiert, er gibt mir dann die 10 ersten aus, leider zeigt er vorher wieder eine Fehlermeldung...glaube ich hab das mit dem Pointer noch nicht ganz verstanden.

Delphi-Quellcode:

Procedure TForm1.OutList;
Var
   x: integer;
   Next: pEintrag;
Begin
   new(Next);
   LBOutNumber.Items.Strings[0] := IntToStr(first.Wert);
   Next := first.Nachfolger;
   For x := 1 To 10 Do Begin
      LBOutNumber.Items.Strings[x] := IntToStr(Next.Wert);
      Next := Next.Nachfolger;
   End;
End;

[Bummi]

Delphi-Quellcode:

Procedure TForm1.OutList;
Var
   x: integer;
   Next: pEintrag;
Begin
   next := First;
   LBOutNumber.Items.Clear;
   while Assigned(next) do
      begin
        LBOutNumber.Items.Add(IntToStr(next.Wert));
        next := next.Nachfolger;
      end;
End;

[Marcel2906]

danke :))

[DeddyH]

Du musst Dich einfach von dem Gedanken lösen, dass Du auf eine verkettete Liste irgendwie indiziert zugreifen könntest :zwinker:

[Marcel2906]

Zitat:

Zitat von DeddyH (Beitrag 1140510)

[edit] Bei doppelt verketteten Listen macht es auch Sinn, neben First ein Last zu haben, das auf dem letzten Element steht, dann kann man die Liste sowohl von vorn als auch von hinten durchlaufen ;) [/edit]

Das habe ich jetzt mal versucht. Aber weiß nicht wie ich das machen soll. Das neu hinzugefügte ist ja quasi immer das letzte...

[DeddyH]

Zitat:

Zitat von Marcel2906 (Beitrag 1140539)

Das neu hinzugefügte ist ja quasi immer das letzte...

Ja eben. Willst Du nun ein neues Element hinzufügen, musst Du nicht mehr von vorn bis hinten die ganze Liste durchgehen, sondern springst gleich zu Last, erstellst das neue Element, weist es Last als Nachfolger zu und machst es dann zum neuen Last.

[Marcel2906]

also so ?! :

Delphi-Quellcode:

Procedure TForm1.AddElement(Wert: integer);
Var
   hlp: PEintrag;
Begin
   // Anfang vorhanden ?
   If (First = Nil) Then Begin
      New(First);
      First^.Vorgaenger := Nil; // Der Anfang der Kette hat keinen Vorgänger;
      First^.Nachfolger := Nil; // Der Nachfolger ist auch erstmal nicht vorhanden.
      last := First;
   End Else Begin
      hlp := First;
      While (hlp^.Nachfolger <> Nil) Do
         hlp := hlp^.Nachfolger;
      New(last);
      last^.Vorgaenger := hlp;
      last^.Nachfolger := Nil;
      hlp^.Nachfolger := last;
   End;
   last^.Wert := Wert;
End;

[DeddyH]

Gerade das Durchhangeln wollen wir uns doch sparen.

Delphi-Quellcode:

Procedure TForm1.AddElement(Wert: integer);
Var
   hlp: PEintrag;
Begin
   // Anfang vorhanden ?
   If (First = Nil) Then Begin
      New(First);
      First^.Vorgaenger := Nil; // Der Anfang der Kette hat keinen Vorgänger;
      First^.Nachfolger := Nil; // Der Nachfolger ist auch erstmal nicht vorhanden.
      last := First;
   End Else Begin
      New(hlp);
      hlp^.Vorgaenger := Last;
      hlp^.Nachfolger := nil;
      Last^.Nachfolger := hlp;
      Last := hlp;
   End;
   Last^.Wert := Wert;
End;

Ungetestet, sollte aber stimmen.