Stack-Überlauf bei Prozeduraufruf

[DarkLord0]

Hiho,

Jedesmal, wenn ich mein Programm folgende Prozedur aufrufen lasse, beendet es sich ohne Fehlermeldung (als hätte man halt benutzt) bzw. mit Fehlermeldung Stack-Überlauf wenn ich es über die IDE starte.

Delphi-Quellcode:

procedure tform1.savedata(satz:data1;filename:string);
var
F: File of data1;
begin
showmessage('#1');
try
AssignFile(F,ExtractFilePath(ParamStr(0))+'1.tmp');
ReWrite(F);
Write(F,satz);
finally
CloseFile(F);
end;
end;

data1 ist ein Record der Größe ~3.16MB, kann es vielleicht an der Größe liegen?
Es wird noch nicht einmal die showmessage('#1') angezeigt, bevor die Meldung kommt bzw. das Programm weg ist.
Woran kann das liegen?

[pszopp]

Hi,

wie ist denn der Record aufgebaut?

teste das mal:
procedure tform1.savedata(const satz:data1; filename:string); PS: den filename kannst auch aus der Parameterliste entfernen, da er nicht benutzt wird.

Gruß,
pszopp

[DarkLord0]

Zitat von pszopp:

teste das mal:
procedure tform1.savedata(const satz:data1; filename:string);

Cool, danke. Das hat funktioniert! Ich frage mich nur, warum

[Dax]

Wenn du const (bzw var) vor einen Parameternamen setzt, wird nur ein Zeiger auf diesen Parameter im Speicher in die Prozedur/Funktion übergeben (also 4 Bytes). Tust du das nicht, wird der Parameter auf den Stack geschrieben (bei dir über 3 Megabytes)... Das verursacht den Stacküberlauf.

[DarkLord0]

Ich habe jetzt noch ein weiteres Problem. In meinem Record ist auch eine Objekt eines selbstdefinierten Typs enthalten (also mit eigenen properties, funktionen und prozeduren). Im Moment wird immer nur ein 4 Byte großer Pointer auf das Objekt gespeichert, das hilft mir natürlich wenig, ich möchte das ganze Object speichern lassen. Kann man in der Definition des Records irgendwie angeben, dass nicht nur eine Pointer-Variable benutzt werden soll? Wann wird überhaupt allgemein von Delphi eine Pointer-Variable benutzt und wann wird auch der Inhalt gespeichert? (kenne das bis jetzt nur bei arrays, wenn man die Größe nicht angibt).

[Olli]

Das entscheidet der Compiler noch immer selber. Wenn du mehr als 64bit übergibst, wird normalerweise der Zeiger benutzt.

64bit wird normalerweise in einer Registerkombination als EAX:EDX übergeben. Alles was 32bit oder drunter ist, wird entweder im Register übergeben (Standard) oder - wenn du zuviele Parameter hast - auf den Stack geschoben.

[pszopp]

Zum Speichern/Laden der Properties müsstes du das Objekt am Besten mit den Methoden
LoadFromStream und SaveToStream ausstatten.
In diesen Methoden musst du dann die Properties leider alle manuell speichern/laden.

Delphi-Quellcode:

procedure TObj.SaveToStream(aStream : TStream);
var lk  : Integer;
    Anz : Integer;
begin
  Anz := Length(Data);
  aStream.Write(Anz, SizeOf(Anz)); 
  for lk := 0 to Anz - 1 do begin
    aStream.Write(Data[lk], SizeOf(Data[lk])); // Data ist z.B. ein Array of Integer
  end; // for lk
end;


procedure TObj.LoadFromStream(aStream : TStream);
var lk  : Integer;
    Anz : Integer;
begin
  aStream.Read(Anz, SizeOf(Anz)); 
  SetLength(Data, Anz);
  
  for lk := 0 to Anzahl - 1 do begin
    aStream.Read(Data[lk], SizeOf(Data[lk])); 
  end; // for lk
end;

(ungetestet)

Gruß,
pszopp