Problem mit Pointern

[fwsp]

hallo

ich hab da ein problem mit pointern, immer wenn ich den code ausführ, bekomm ich ne AV. aber eigentlich sollte doch speicherplatz reserviert sein. ich kenn mich nicht so toll mit pointern aus, vielleicht findet jemand den fehler?

die funktion kriegt im prinzip nen string, mit gewissen buchstaben, und zeichnet daraufhin nach bestimmten regeln. ist ein lindenmayer-system.

danke.

hier die typ deklarationen:

Delphi-Quellcode:

type
  PPosition =  ^TPosition;
  TPosition = record
    x: Integer;
    y: Integer;
    xHlp: Integer;
    yHlp: Integer;
end;

hier die funktion:

Delphi-Quellcode:

procedure DrawIteration(Const Axiom: String; L, Degree: Real;
  var Turtle: TTurtle; var ProgBar: TProgressBar);
var
  i: Integer;
  Pt:  ^TPosition;
begin
  GetMem(Pt, 0);
  ProgBar.Max := Length(Axiom);
  for i := 1 to Length(Axiom) do
  begin
    Application.ProcessMessages;
    case Axiom[i] of
      'F':  Turtle.FD(L);

      'f':
      begin
        Turtle.PU;
        Turtle.FD(L);
        Turtle.PD;
      end;

      '+':  Turtle.LT(Degree);

      '-':  Turtle.RT(Degree);

      '[':
      begin
        GetMem(Pt, (SizeOf(Pt) + SizeOf(TPosition)));
        Pt.x := Turtle.PosX;
        Pt.y := Turtle.PosY;
        Turtle.PU;
        Turtle.FD(250);
        Pt.xHlp := Turtle.PosX;
        Pt.yHlp := Turtle.PosY;
        Turtle.MoveXY(Pt.x, Pt.y);
        Turtle.PD;
      end;

      ']':
      begin
        Turtle.PU;
        Turtle.MoveXY(Pt.x, Pt.y);
        Turtle.SetHXY(Pt.xHlp, Pt.yHlp);
        GetMem(Pt, (SizeOf(Pt) - SizeOf(TPosition)));
        Turtle.PD;
      end;
    end;
    ProgBar.Position := i;
  end;
  FreeMem(Pt);
end;

[Muetze1]

1. Warum "GetMem(Pt, 0);" ? Wenn du 0 Bytes an Speicher reservieren willst, dann ist der ganze Aufruf hinfällig.
2. Warum arbeitest du überhaupt mit einem Zeiger auf die Struktur? Arbeite direkt mit der Struktur und dann brauchst du dich nicht um Speicher Alloziierung und freigeben kümmern.

Delphi-Quellcode:

procedure DrawIteration(Const Axiom: String; L, Degree: Real;
  var Turtle: TTurtle; var ProgBar: TProgressBar);
var
  i: Integer;
  Pt: TPosition;
begin
  ProgBar.Max := Length(Axiom);

  for i := 1 to Length(Axiom) do
  begin
    Application.ProcessMessages;
    case Axiom[i] of
      'F':  Turtle.FD(L);

      'f':
      begin
        Turtle.PU;
        Turtle.FD(L);
        Turtle.PD;
      end;

      '+':  Turtle.LT(Degree);

      '-':  Turtle.RT(Degree);

      '[':
      begin
        Pt.x := Turtle.PosX;
        Pt.y := Turtle.PosY;
        Turtle.PU;
        Turtle.FD(250);
        Pt.xHlp := Turtle.PosX;
        Pt.yHlp := Turtle.PosY;
        Turtle.MoveXY(Pt.x, Pt.y);
        Turtle.PD;
      end;

      ']':
      begin
        Turtle.PU;
        Turtle.MoveXY(Pt.x, Pt.y);
        Turtle.SetHXY(Pt.xHlp, Pt.yHlp);
        Turtle.PD;
      end;
    end;
    ProgBar.Position := i;
  end;
end;

Das sollte doch eigentlich vollkommen reichen, wenn ich das so richtig überschaut habe. Das einzige mögliche Problem was ich dabei sehe: Es darf niemals eine ] vor einer [ kommen. Wenn dies gewährleistet ist, dann sollte das so funktionieren.

[fwsp]

ich muss mit pointern arbeiten, sagt mein lehrer...

zweitens ich muss auf alle fälle mit dynamischen strukturen arbeiten, da der string auch mal gerne ne million zeichen haben kann. hier ist ein beispiel für so nen string:

Code:

F[+F][-F]F[+F[+F][-F]F][-F[+F][-F]F]F[+F][-F]F[+F[+F]
[-F]F[+F[+F][-F]F][-F[+F][-F]F]F[+F][-F]F][-F[+F][-F]
F[+F[+F][-F]F][-F[+F][-F]F]F[+F][-F]F]F[+F][-F]F[+F[+
F][-F]F][-F[+F][-F]F]F[+F][-F]F

[Der_Unwissende]

Hi,
mal ein wenig zu den Pointern. Schau dir mal in der OH GetMem an. Da wirst du dann sehen, dass du eher zu New (und Dispose) greifen sollst. Warum musst / kannst du dort dann aber keine Größe angeben? Ganz einfach, Pointer sind echt nur Zeiger auf eine Adresse im Speicher. Die Größe deiner Adresse ist dabei fest durch dein BS vorgegeben (i.d.R. dürften dass also 32Bit / 4 Byte sein).
Wichtig ist hier zu verstehen, dass ein Pointer wirklich immer gleich groß ist, SizeOf(Pt) liefert dir immer 4 (so groß ist nämlich dein Pointer), sizeOf(pt^) sollte hingegen die Größe der Daten hinter pt liefern. Darin liegt auch der volle Vorteil von Pointern, du musst nicht mehr xxx Byte übergeben sondern nur noch eine Adresse (und die ist immer ein Register breit und damit optimal in der Größe).

Gruß Der Unwissende

[fwsp]

das mit New und Dispose hat mir auch schon die hilfe von d7 gesagt, wir sind aber angwiesen worden mit GetMem und FreeMem zu arbeiten.

[Dax]

Dann nimm GetMem(Pt, sizeof(TPosition)); und FreeMem(Pt);. Das sollte immer klappen.. Aber ich versteh euren Lehrer echt nich :gruebel:

[markusj]

Mal so ganz am Rande ... wo tritt die AV eigentlich auf???

[fwsp]

jetzt krieg ich:

Code:

---------------------------
L-System
---------------------------
Ungültige Zeigeroperation.
---------------------------
OK   
---------------------------

und zwar an der selben stelle wie zuvor:

Delphi-Quellcode:

      ']':
      begin
        Turtle.PU;
        Turtle.MoveXY(Pt.x, Pt.y);
        Turtle.SetHXY(Pt.xHlp, Pt.yHlp);
        FreeMem(Pt);
        Turtle.PD;
      end;

[markusj]

Was passiert, wenn du FreeMem weglässt???

[fwsp]

dann gibt es keine exception, allerdings wird dann auch nicht auf das richtige zugegriffen - das gezeichnete sieht dann anders aus als es sollte.