Ungültige Zeigeroperation (FreeMem)

[Alter Mann]

Moin,

nachdem ich nun Besitzer von 10.1 Update 1 Prof bin, wollte ich 'alten' Code weiterverwenden,
doch nun bekomme ich aufeinmal die Fehlermeldung: 'Ungülltige Zeigeroperation' an dieser Stelle:

Code:

...
var
  Buffer : Pointer;
  Msg    : String;
  dwSize : DWORD;
  dwBW   : DWORD;
...
  dwSize := Length(Msg) * SizeOf(Char) + 1;
  dwBW   := 0;
  GetMem(Buffer, dwSize);
  Move(Msg, Buffer, dwSize);
  Result := WriteFile(FHandle, Buffer, dwSize, dwBW, nil);
  FreeMem(Buffer, dwSize);                                               [COLOR="Lime"]<- Hier[/COLOR]
...

Schon etwas Komisch, da es bei der Starter Edition 10.1 und früheren Versionen keine Fehlermeldung gab.

Hat jemand einen Tipp?

[Uwe Raabe]

Ich wundere mich, daß das überhaupt je funktioniert haben soll.

Move(Msg, Buffer, dwSize);
kopiert den Pointer auf einen Text (= eine String-Variable) in einen untypisierten Pointer, aber nicht den Textinhalt in den Speicherbereich, auf den der Pointer zeigt. Das spätere FreeMem gibt dann also Speicher frei, der eigentlich der string-Variablen gehört.

Müsste es nicht eher so heißen:

Move(Msg[1], Buffer^, dwSize);

Ähnlich auch bei WriteFile

WriteFile(FHandle, Buffer^, dwSize, dwBW, nil);

[jaenicke]

// EDIT: hatte den Tab wohl zu lange offen, ich lasse es mal trotzdem so

Ich frage mich wie das jemals funktioniert hat. Vielleicht gab es vorher ein anderes Move als System.Move?

Move bekommt einen Puffer als ersten Parameter, d.h. du müsstest das erste Zeichen übergeben, nicht den String (was intern ja ein Pointer ist). Und warum das +1 bei der Größe? So schreibst du die eine Hälfte des Nullzeichens mit in die Datei!?

Dazu kommt, dass WriteFile genau wie Move im zweiten Parameter einen Puffer übergeben bekommt und keinen Pointer auf die Daten.
Eventuell hat sich diese Deklaration in Delphi irgendwann geändert.

So wäre es korrekt:

Delphi-Quellcode:

var
  Buffer : Pointer;
  Msg   : String;
  dwSize : DWORD;
  dwBW  : DWORD;
...
  dwSize := Length(Msg) * SizeOf(Char);
  dwBW  := 0;
  GetMem(Buffer, dwSize);
  Move(Msg[1], Buffer^, dwSize);
  Result := WriteFile(FHandle, Buffer^, dwSize, dwBW, nil);
  FileClose(FHandle);
  FreeMem(Buffer, dwSize);

Allerdings frage ich mich warum du das so kompliziert machst. Warum nicht einfach so?

Delphi-Quellcode:

var
  Msg   : String;
  dwSize : DWORD;
  dwBW  : DWORD;
...
  dwSize := Length(Msg) * SizeOf(Char);
  dwBW  := 0;
  Result := WriteFile(FHandle, Msg[1], dwSize, dwBW, nil);

[Alter Mann]

Hi,

Code:

procedure Move(const Source; var Dest; Count: NativeInt);

Das +1 kommt daher, dass ja noch Platz für das abschließende #00 sein soll.

Hat aber nichts mit FreeMem zu tun.
Der Code läuft garantiert unter D5, D7, D2009, XE8 und 10.1 Starter, nur nicht unter 10.1 Up1.
Und das ist das Problem.

[EDIT]
Ich maches es jetzt so:

Code:

Result := WriteFile(FHandle, Pointer(Msg)^, dwSize, dwBW, nil);

[/EDIT]

DANKE

[Uwe Raabe]

Zitat von Alter Mann:

Hat aber nichts mit FreeMem zu tun.

Natürlich hat es das! Wenn du den Pointer unter Buffer überschreibst, dann kann das FreeMem damit nicht mehr wirklich was anfangen.

Zitat von Alter Mann:

Der Code läuft garantiert unter D5, D7, D2009, XE8 und 10.1 Starter, nur nicht unter 10.1 Up1.
Und das ist das Problem.

Das ist wohl eher Zufall!

[jaenicke]

Zitat von Alter Mann:

Das +1 kommt daher, dass ja noch Platz für das abschließende #00 sein soll.

Erstens sind ein Nullzeichen SizeOf(Char) = 2 Byte, nicht nur 1 Byte, und zweitens ist das innerhalb einer Datei absolut unüblich ein Nullzeichen drin zu haben.

Zitat von Alter Mann:

Der Code läuft garantiert unter D5, D7, D2009, XE8 und 10.1 Starter, nur nicht unter 10.1 Up1.

Bei mir nicht und ich hätte mich auch gewundert. Denn die Parameter für Move und WriteFile sehen da schon genauso aus.

[Ghostwalker]

Ist zwar schon ne weile her seit ich Delphi programmiert hab aber das:

Code:

Result := WriteFile(FHandle, Pointer(Msg)^, dwSize, dwBW, nil);

wird so auch nicht wirklich funktionieren, wenn ich das noch richtig im Kopf hab.

Damit interpretierst du nur die ersten 32 Bit des Strings als Adresse, aber der der Inhalt stehen soll.

Die Variante von jaenicke wär die einfachste, die auch wirklich funktioniert.

[jaenicke]

Doch, Pointer(Msg)^ geht. Das liegt daran, dass ein String intern ein Pointer auf die Stelle im Speicher zwischen Referenzzähler, Stringlänge und dem Stringinhalt selber ist. Ein Cast auf Pointer ergibt daher den Pointer auf das erste Zeichen und durch dessen Dereferenzierung landet man beim ersten Zeichen. Das als Puffer übergeben funktioniert dann.

[Alter Mann]

Moin, Moin,

ich glaub, ich werde alt

Ihr habt nartürlich Recht.

[himitsu]

Na das Problem lasst sich leicht lösen.

Benenn dich doch einfach um.







Junger Mann