Suche Beispiel, um Zeiger besser zu verstehen

[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