Ist folgender Code "sicher"?

[atc]

Hallo,

ich mache gerade etwas mit Zeigern und frage mich ob folgender Code so OK ist?

Delphi-Quellcode:

type
  TRec = record
    S: string;
    A: array of string;
  end;
  PRec = ^TRec;

var
  P1: PRec;
  P2: Pointer;
  I : Integer;
begin
  Writeln(SizeOf(TRec));

  New(P1);
  P1^.S := 'test';
  SetLength(P1^.A, 0);

  P2 := P1;

  for I := 1 to 10 do
    with PRec(P2)^ do
    begin
      S := S + 'a';
      SetLength(A, Succ(Length(A)));
      A[High(A)] := 'test' + IntToStr(Length(A));
    end;

  with PRec(P2)^ do
  begin
    Writeln(PRec(P2)^.S);
    for I := Low(A) to High(A) do
      Writeln(A[I]);
  end;

  Readln;
end.

Mit New() wird ja, glaube ich, nur Speicher für 2 Zeiger angelegt und nicht für beliebig lange Strings, oder?
Ist es dann OK den String und das Array wie oben zu verändern/vergrößern oder kann es da "knallen"? Also wird automatisch neuer Speicher angefordert?

Eine andere Frage ist, ob es einen Unterschied macht, wenn ich PRec(P2)^.S oder TRec(P2^).S schreibe?

Danke für jede Antwort

[Furtbichler]

Ja (is ok), Nein (macht keinen Unterschied).

[atc]

Danke

[shmia]

Also ich würde den Code als unsicher und "gefährlich" einstufen.
Zeigeroperationen sind potentiell gefährlich. Punkt!
Ein winzig kleiner Fehler und schon kann der halbe Stack zerstört werden.

Es kommt aber darauf an, wie man damit umgeht.
Wenn man, wie das zum Beispiel die VCL mit der der Klasse TList tun, Zeigeroperationen schön
in Klassen oder zumindest Funktionen verpackt dann geht das in Ordnung.

Was nicht in Ordnung ist wenn man Zeigeroperationen einfach so ohne schützende Hülle
in die Anwendung pflanzt.
Bei einem kleinen Testprogramm mag das noch kein Problem darstellen,
aber wenn die Anwendung wächst, dann sind das tickende Zeitbomben.

Code der Daten per Zeiger verändert ist wie eine geladene Schusswaffe -
wer die Waffe nicht in einen Tresor wegsperrt darf sich nicht wundern wenn plötzlich
unschuldige Speicherplätze gekillt werden.

[himitsu]

Für irgendwas müssen die Generics ja gut sein ... da kann man sich viel rumgecaste/rumgepointere sparen, da es automatisch und vorallem typsicher behandelt wird.

[BUG]

Es gibt auch noch ein kleines Speicherleck (oder habe ich da ein Dispose übersehen?).

[DeddyH]

Das war mir auch aufgefallen. New -> Dispose, GetMem -> FreeMem, das sollte man schon einhalten.

[Furtbichler]

Lustig, da fragt jemand, ob der Code sicher ist (DIESER Code ist es) und dann wird eine Abhandlung daraus, das Pointer per se unsicher sind. Man kann dann ja auch sagen, das das Leben per se tödlich ist.

Lustig finde ich auch, das man fälschlicherweise ein Speicherleck erwähnt, nur weil in DIESEM Code am Ende ein (an dieser Stelle zudem überflüssiges) FreeMem fehlt. Also ich will mich nicht zu weit aus dem Fenster lehnen, aber ich bin mir ziemlich sicher, das sukzessives Aufrufen dieses kleinen Programms nicht dazu führt, das Windows irgendwann mit einem OutOfMemory anhält.

Natürlich sollte man die immer freigeben, was man anfordert (einfach aus Prinzip), und Pointer (wie auch Endlosschleifen) echt böse und gefährlich sein können, wenn man keine Ahnung hat, aber der Hinweis, das beide Bemerkungen nichts mit der Frage zu tun haben, sondern allgemein gehaltene Tipps sind, wäre imho angebracht. Ansonsten würde ich nämlich annehmen, das die Frage nicht verstanden wurde.

[shmia]

Zitat von Furtbichler:

... aber der Hinweis, das beide Bemerkungen nichts mit der Frage zu tun haben, sondern allgemein gehaltene Tipps sind, wäre imho angebracht. Ansonsten würde ich nämlich annehmen, das die Frage nicht verstanden wurde.

Ich denke JEDER der Beitrag #4 gelesen hat, wird verstehen, dass es sich um allgemeine Tipps handelt; das muss also nicht noch explizit erklärt werden.

Eigentlich wollte ich ja schreiben das der Code aus Beitrag #1 hässlich und altmodisch ist, habe dann aber lieber allgemeine Hinweise gegeben.
Das war zumindest ein konstruktiver Beitrag für alle die dazulernen möchten; im Gegensatz zu deinem Rant.