Verkettung ? Fragen für Info-Klausur

[Hansa]

Hi,

Zitat:

und darum wollte ich fragen ob mir jemand von euch das Prinzip der Verkettung erklären kann
und wofür man sachen wie "new(a)" oder "a^:='B'" braucht.

new ist ja schon erklärt. dispose ist das Gegenteil davon. Pass aber verdammt auf, daß Du a^ und ^a nicht verwechselst, also ob das ^ vor oder hinter dem Bezeichner steht ! Das ist ein himmelweiter Unterschied. Mit a^ kriegst Du den Inhalt des Speichers (siehe oben) an der Stelle a direkt. ^a aber ist die Stelle an der der Inhalt des Zeigers liegt !!! Stimmt das überhaupt ? Vorsichtshalber : ohne Gewähr.

Gruß
Hansa

P.S.: Wann ist die Klausur ?

[VeeJay]

Das mit dem "Wortspiel" hab ich jetzt verstanden und ich bin bei der erweiterten Version und brauche wohl wieder Hilfe
Also:

Delphi-Quellcode:

Type pkette = ^knoten;         // p steht für Pointer
     knoten    = RECORD
                   wort : string;   next : pKette;
                 END;

...das OOP hab ich ja eigentlich drauf, aber das verstehe ich nicht ?
Wäre gut wenn mir jemand erklären könnte warum ein Typ pkette eine Eigenschaft, die auch pkette heißt, haben kann und vielleicht auch alles andere an dem Type.

Danke nochmal für alles, was ihr mir bis jetzt erklärt habt

[Hansa]

Hi,

aha, bist auch noch dran. Wie ich sehe läuft das auf meine Vermutung mit der verketteten Liste hinaus. Konnte fast nur so sein.

Zitat von VeeJay:

Delphi-Quellcode:

Type pkette = ^knoten;         // p steht für Pointer
     knoten    = RECORD
                   wort : string;   
                   next : pKette;
                 END;

...das OOP hab ich ja eigentlich drauf, aber das verstehe ich nicht ?

Wann ist die Klausur ? Das frage ich nicht umsonst ! Ist sie nächste Woche, kannst Du das hier getrost vergessen. Nun gut :

1. Dein Quelltext war für diese Zwecke unleserlich, was nur bedeutet, daß wort und next in einer Zeile stehen. Kleine Ursache, aber große Wirkung.

2. vergiß OOP, das hat in diesem Zusammenhang nichts zu bedeuten.

3. next reicht den Zeiger an das nächste Element, welches wiederum vom Typ pKette ist und auch einen Inhalt hat. Mit Inhalt sind die Daten gemeint ("wort") ! Zusätzlich das nächste Element wieder ein next, nämlich das des nächsten Elementes.

Tip : vergiss in diesem Zusammenhang alles, was Du über Delphi weißt. Das ist für jede Programmiersprache gültig. Ähm, wann ist nochmal die Klausur ?

Gruß
Hansa

[VeeJay]

Die Klausur ist am 10.01.
Unser Info-Lehrer war so freundlich uns all die Sachen
über die Ferien auf zu geben. Wir hatten nur 1 Stunde Unterricht
darüber. Und in der haben wir das Beispiel ganz oben gemacht.
Was ich hier poste ist vielleicht ein Achtel von allem, was wir noch
machen müssen

Meinst du das krieg ich noch hin, zumindest mit den verketteten Listen?

Hier ist noch der restliche Code:

Delphi-Quellcode:

unit Unit1;   //Zeiger_verkett1 (ohne Verkettungsprozedur)
// Aufgaben: 1) Erkläre den Datentyp "knoten" (siehe unten)
//           2) Welche Ausgabe ist am Ende in Edit1.Text zu erwarten?
//           3) Was versteht man bei der Reihenfolge der Daten unter LIFO ?
//           4) Welche Vorteile bringt die dynamische Verkettung von Daten?
interface

uses  Windows, Messages, SysUtils, Classes, Graphics,
      Controls, Forms, Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
  public
  end;

var
  Form1: TForm1;
  Satz : string;

implementation {$R *.DFM}
//---------------------------------------------------
Type pkette = ^knoten;         // p steht für Pointer
     knoten    = RECORD
                   wort : string;   next : pKette;
                 END;
//---------------------------------------------------
Var kette: pKette;

procedure TForm1.Button1Click(Sender: TObject);
Var neu, hilf :pKette;
begin
  kette:=nil;    //Die Kette erhält einen Anfang
  satz:='';

  New(neu);      //Ein neues Kettenglied wird erzeugt
  neu.wort:='Das ';
  neu.next:=kette;
  kette:=neu;    //...und angehängt

  New(neu);      //...noch ein Kettenglied
  neu.wort:='wars ';
  neu.next:=kette;
  kette:=neu;

  New(neu);     //...und noch eines
  neu.wort:='schon ';
  neu.next:=kette;
  kette:=neu;
  {---------------------------------------------}

  satz:=kette^.wort;    // Die Kette wird ausgelesen

  {Wenn wir den Kettenzeiger nicht verändern und statt-
  dessen den Hilfzeiger, können wir den Anfang der
  Kette stets wiederfinden!}

  hilf:=kette^.next;    // Zum nächsten...
  satz:=satz+hilf^.wort;

  hilf:=hilf^.next;     // Zum nächsten...
  satz:=satz+hilf^.wort;

  edit1.text:=satz;     // Ausgabe am Bildschirm

end;

end.

[Hansa]

Hi,

Zitat:

Meinst du das krieg ich noch hin, zumindest mit den verketteten Listen?

Ehrlich gesagt : Glaub es nicht. Das hat aber mit Dir nichts zu tun. Aber in einer Woche ist das nicht zu schaffen. Das ist pure Theorie. Da nützt Dir kein Delphi und die beste VCL auch absolut nichts. Warum machen die Heinis das wohl erst ganz am Schluß? Weil sie selber keine Ahnung haben. Bei starken Nerven : Schreibe in der Klausur in einem gewissen Zusammenhang

Code:

a^ := next; x := a;

usw., wahrscheinlich guckt der nur nach ; := und so. Der ist viel zu faul, alles durchzugehen.

Gruß
Hansa

P.S.: Auf keinen Fall würde ich wegen dieses Themas etwas anderes vernachlässigen. Vermute fast, daß eine Aufgabe mit Pointern überhaupt nicht kommt.

[Christian Seehase]

Moin VeeJay,

1. Der Datentyp Knoten ist ein Recordtyp mit zwei Datenfeldern.
   Zum einen einem string mit der Bezeichnung Wort, und zum anderen mit einem Zeigertyp auf den Typ Knoten und der Bezeichnung next.
2. schon wars Das
3. LIFO steht für Last In First Out
   Auf das was als letztes hinzugefügt wird, wird als erstes wieder zugegriffen.
   Paradebeispiel: Tellerstapel
   Der Teller den man zuletzt draufgelegt hat, wird man wohl, aller voraussicht nach, als erstes wieder herunternehmen.
4. Wie ich oben schon geschrieben hatte:
   Man kann problemlos neue Daten einsortieren (hinzufügen), ohne die gesamten Daten umsortieren zu müssen, ebenso problemlos lassen sich Daten auch löschen, indem einfach nur der Zeiger auf ein Element auf das dem zu löschende Folgende gesetzt wird

Bestimmt werden diese Ausführungen noch ergänzt werden

Anmerkung:
Wenn das Beispiel von Deinem Lehrer stammt, dann hat er es aber inkonsequent geschrieben.
Entweder er schreibt den dereferenzierungsoperator ^ immer mit oder nie, aber nicht mal so und mal so.
Eigentlich müsste jede neu.xxxx neu^.xxxx geschrieben werden, oder statt kette^.xxxx und hilf^.xxxx kette.xxxx und hilf.xxxx.
Aber dieser, unnötige, Wechsel kann doch recht verwirrend sein.

Das Weglassen funktioniert aber auch nur, weil der Compiler clever genug ist zu wissen was gemeint ist, wenn man neu.wort schreibt (und das ^ weglässt)

[Hansa]

Hi VeeJay,

Christian Seehase hat eine ähnliche Vermutung, wie ich. Der hat nicht viel Ahnung. Liest Du seinen Kommentar, verstehst Du hoffentlich, warum ich frage, wann die Klausur ist ? Also : Pokerspieler (J/N) ? Falls ja : mit Antworten bluffen, falls Nein : vergiss es. Ansonsten kann ich Dir nicht mehr viele Tips geben.

@Christian Seehase : @VeeJay : hier nicht weiterlesen, das verwirrt Dich nur. Was ist mit doppelt-verketteten Listen oder zyklische, die ich schon angedeutet habe ?

Gruß
Hansa[/quote]

[fiasko]

Auch wenn das Posting schon ein Stück weiter oben steht...

Zitat von Hansa:

Pass aber verdammt auf, daß Du a^ und ^a nicht verwechselst, also ob das ^ vor oder hinter dem Bezeichner steht ! Das ist ein himmelweiter Unterschied. Mit a^ kriegst Du den Inhalt des Speichers (siehe oben) an der Stelle a direkt. ^a aber ist die Stelle an der der Inhalt des Zeigers liegt !!! Stimmt das überhaupt ?

Ne stimmt nich. Man kann sich in Delphi zwar vieles erlauben (z.B. den Derefenzierungsoperator ^ bei Zugriff auf record-Elemente weglassen), aber der Referenzierungsoperator ist bei Pascal schon immer ein @ (und dann hat man noch irgendwann die Funktion Addr() eingeführt). Natürlich bissl verwirrend, das aber nur in der Typedef ein ^ davor kommt (dafür darf aber keins dahinter stehen :-).


Thomas

[VeeJay]

Also bei aller Schwierigkeit,
ich denke, ich weiß jetzt schon eine Menge mehr über das Thema als ich noch vor 2 Tagen wusste. Ist echt cool, dass ihr mir das alles zeigt. Ich werde morgen noch mal alles zusammenfassen und gucken ob ich noch Probleme mit bestimmten Sachen habe, die unbedingt noch gelöst werden müssen. Ansonsten werde ich das Prinzip wohl auswendig lernen ohne es zu verstehen
Vielleicht kann mir auch noch jemand den Zusammenhang zwischen a^ und @a
erklären....

Dann bis morgen

[Christian Seehase]

Moin VeeJay,

mit Zusammenhang wird's schwierig

Ich hab' Dir hier mal ein "wildes" Beispiel zusammengestellt:
(um das try/finally brauchst Du Dich erstmal nicht zu kümmern, auch wenn's wichtig ist)

Delphi-Quellcode:

var
  p : PChar; // Pointer auf Char
  c : Char;  // Ein Character

begin
  p := AllocMem(1); // Speicher reservieren und Adresse dieses Speichers nach p
  try
    p^ := 'a';      // Jetzt an diese Stelle ein Zeichen schreiben.
    c  := p^;       // und jetzt dieses Zeichen an die Charactervariable übergeben
    ShowMessage(c); // Anzeigen, dass es auch geklappt hat
  finally
    FreeMem(p,1);   // Nun kann der Speicher wieder freigegeben werden
  end;
  p  := @c;         // Jetzt die Adresse der Charactervariablen nach p
  ShowMessage(p^);  // Und sich das a anzeigen lassen
  c  := 'b';        // Jetzt ein anderes Zeichen in der Charactervariablen speichern
  ShowMessage(p^);  // aber wieder anzeigen lassen, auf was p zeigt... siehe da es erscheint ein b
end;

War das soweit verständlich mit ^ und @ ?