Suche Beispiel, um Zeiger besser zu verstehen

[Luckie]

Motzi hat mal ein Zeigertutorial geschrieben: Motzis Tutorial bei mir.

[Robert_G]

Zitat von Oxmyx:

Delphi-Quellcode:

var
  a, b: Integer;
  pa: PInteger;
begin
  a := 5;

  pa := @a;  // pa zeigt auf a

  b := pa^;  // b wird der Wert zugewiesen, auf den pa zeigt, also hat b den Wert 5
end;

Ich greife das mal einfach auf.
Ist etwas spät und mein Hirn ist schon etwas ranzig ( ). Hoffentlich ist es nicht zu verdreht....

Beispiel 1: Ohne Zeiger

Delphi-Quellcode:

var
  A, B: Integer;
begin
  A := 1;
  B := A;  // a wird auf b KOPIERT
  A := 2;  // a bekommt die 2, b (da es nur eine Kopie ist) bleibt 1

  Writeln('A: ', A);
  Writeln('B: ', B);
end;

Output

A: 2
B: 1

Beispiel 2: Mit Zeigern

Delphi-Quellcode:

program Pointers;

{$APPTYPE CONSOLE}

type ZeigerAufEinenInteger = ^Integer;
var
   A, B: Integer;
   pC  :ZeigerAufEinenInteger;
begin
   A  := 1;
   pC := @A;  // pC bekommt den Verweis auf A. -> beide zeigen auf den selben Wert
   ZeigerAufEinenInteger(B)  :=  pC;  // der Verweis wird an B als Wert weitergereicht
   A  := 2;  // a bekommt die 2, b (da es nur eine Kopie ist) bleibt 1

   {Output 1}
   Writeln(' A: ', A);
   Writeln(' B: ', ZeigerAufEinenInteger(B)^); // B enthält als eigentlichen Wert nicht die 2 sondern die Addresse von A
                                               // Wenn wir auf diese Adresse zeigen und den Wert mit  einem
                                               // ^ herausholen (dereferenzieren) haben wir A

   Writeln('pC: ', pC^); // Auch pC enthält als Wert die Adresse von A, brauchst aber
                         // als Pointer keinen Cast auf einen Pointertyp

   A  := 3;  // A bekommt jetzt die 3 und wieder sollten B & pC auch auf die 3 zeigen

   {Output 2}
   Writeln(' A: ', A);
   Writeln(' B: ', ZeigerAufEinenInteger(B)^);
   Writeln('pC: ', pC^);

   {Output 3}
   // hier lassen wird uns die Adresse der 3 Variablen zeigen
   // Da sie alle uneterschiedliche Variablen sind, sind ihre Adressen auch unterschiedlich
   Writeln('Addresse von  A: ', Integer(@A));
   Writeln('Addresse von  B: ', Integer(@B));
   Writeln('Addresse von pC: ', Integer(@pC));

   {Output 4}
   // und nun die Werte...

   Writeln('Wert von  A: ' , A);         // A ist bekanntlich 3
   Writeln('Wert von  B: ' , B);         // B enthältals Zahl die Adresse von A (vergleiche mit Output3)
   Writeln('Wert von pC: ', Integer(pC));// als Zeiger auf A enthält pC die Adresse von A
                                         // pC und B haben hier also die gleiche Funktion
end.

Output 1

A: 2
B: 2
pC: 2

Output 2

A: 3
B: 3
pC: 3

Output 3

Addresse von A: 4237208
Addresse von B: 4237212
Addresse von pC: 4237216

Output 4

Wert von A: 3
Wert von B: 4237208
Wert von pC: 4237208

[Hansa]

Zitat von Robert_G:

Beispiel 1: Ohne Zeiger

So reichts auch vollkommen, zumindest für diesen Zweck.

[perle]

ich habe eine ganz kleine Frage zu Motzis Tutorial, dafür will ich nicht extra nen Thread aufmachen, da das vielleicht auch ganz interessant für den Themenstartet sein könnte.....

Zum erzeugen der Forms benutzt Motzi folgenden Code :

Delphi-Quellcode:

procedure TMainForm.CreateButtonClick(Sender: TObject);
begin
  GetMem(FormP, SizeOf(TMultipleForm)); // --> reserviert an der Adresse von FormP den Speicher für die Form
  FormP^ := TMultipleForm.Create(Self); // --> erzeugt die Form
  FormP^.Caption := FormP^.Caption + IntToStr(Liste.Items.Count + 1);
  FormP^.Label1.Caption := LabelText.Text;
  FormP^.OnHide := ListeClick; // --> beim verstecken des Fensters muss ja die Button-Aufschrift aktualisiert werden...
  FormListe.Add(FormP); // --> fügt den Pointer zur Liste hinzu
  Liste.Items.Add('Form' + IntToStr(Liste.Items.Count + 1));
end;

mir stellte sich dann die Frage ob man das ganze Konzept nicht auch folgendermaßen machen könnte :

Delphi-Quellcode:

procedure TMainForm.CreateButtonClick(Sender: TObject);
begin
  FormListe.Add(TMultipleForm.Create(Application));
  TMultipleForm(FormListe[FormListe.Count - 1]).Caption := 'Form' + IntToStr(Liste.Items.Count + 1);
  TMultipleForm(FormListe[FormListe.Count - 1]).Label1.Caption := LabelText.Text;
[...]
end;

usw.... beim Testen hat das so eigetnlich funktioniert und logisch wärs doch eigentlich auch , da ein Typ doch eigentlich auch nur ein Pointer ist !?

Wo lägen dort Vor- bzw. Nachteile
und wofür muss man explizit das GetMem machen? Was passiert wenn man es weg lässt?

Fragen über Fragen, dankbar für Antworten

[Motzi]

@perle: du hast es durchschaut!!

Das Tutorial ist schon seeehr alt und ich war bist jetzt zu faul es zu überarbeiten / bzw hab es verdrängt.. Aber du hast recht, da Objekte implizit ohnehin nur Zeiger sind kann man direkt mit diesen arbeiten anstatt zuerst einen Pointer auf einen Pointer zu deklarieren.

Ich hab aber gestern abend beschlossen (und bereits begonnen) das Tutorial mal kräftig zu überarbeiten und auch bessere Beispiele einzubringen...

[Robert_G]

Zitat von Motzi:

Aber du hast recht, da Objekte implizit ohnehin nur Zeiger sind kann man direkt mit diesen arbeiten anstatt zuerst einen Pointer auf einen Pointer zu deklarieren.

Kann ist gut. Ich sehe überhaupt keinen Sinn hinter Pointern auf Objektzeiger. Schließlcih ist es nicht nur einfacher und lesbarer sondern auch noch schön typen sicher.

[mika]

Lernen muss ja net immer langweilig sein oder aus Hilfedateien bestehen

guck mal hier:

Pointer Videos mit "Binky dem Pointer"

ziemlich spassig find ich



lg, mika