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.

[Der_Unwissende]

Sorry, noch mal ganz kurz an die Leute die dir hier helfen wollen (und natürlich auch an dich), ich glaube ein paar ist der ursprüngliche Fehler nicht bewußt.
Wenn ich den Code richtig deute möchte er ein dynamisches Array erstellen aber halt zu Fuß mit Pointern. Der eigentliche Fehler lag definitiv in sizeOf(pt), damit erhöhst du nie im richtigen Masse die Größe des Arrays (also deines reservierten Speichers). Die Access Violation resultiert also in der Aktion GetMem(pt, sizeOf(pt) - sizeOf(TPosition)). Das ist einfach mal 4 - 16 Bytes reservieren (-> ungültiger Pointer).

[Hawkeye219]

Hallo,

der Fehler in deinem Algorithmus wird durch den falschen Umgang mit Pointern verursacht. Wie du ja bereits richtig erkannt hast, wird eine neue Gruppe durch das Zeichen "[" geöffnet und durch das Zeichen "]" wieder geschlossen. Beim Schließen der Gruppe muß der vorherige Zustand des Systems wiederhergestellt werden. Du hast nun versucht, eine Art "Pointer-Array" zu realisieren und dieses durch GetMem-Aufrufe zu vergrößern und zu verkleinern. Das ist aber in Delphi so, wie du es programmiert hast, nicht möglich.

Da ihr offenbar nicht mit dynamischen Arrays arbeiten dürft, solltest du über den Einsatz einer verketteten Liste nachdenken. Erweitere den Record TPosition um ein Feld vom Typ PPosition, das auf das nächste Element der Liste zeigt. Beim Öffnen einer Gruppe legst du nun ein neues Element an und verkettest es mit deiner bisherigen Liste. In diesem neuen Element kannst du den aktuellen Zustand des Systems sichern. Beim Schließen einer Gruppe restaurierst du das System aus dem zuletzt eingefügten Element und entfernst es aus der Liste. Wenn du neue Elemente immer am Anfang der Liste einfügst, benötigst du nur einen Verweis auf das erste Listenelement und kommst mit einer einfach verketteten Liste aus.

Gruß Hawkeye