Ich hab da mal nen Problem, und zwar würd ich gern ein

array[0..640, 0..480] of Cardinal

verwenden, nur leider sagt mit Delphi sobald ich es benutzen will Stack overflow.

mit nem array[0..640, 0..480] of word

klappt alles, nur leider ist word zu klein für mein Anliegen ich brauch schon was größeres, was mach ich da?


Wer hat Rat?

Das Array als array of array of Cardinal deklarieren und vor der Benutzung mit SetLength(MyArray, 640, 480) initialisieren. Dann liegt das Array auf dem Heap und dein Stack ist sicher

werde ich sofort versuchen, ich berichte dann ob der Heap dann überläuft! (falls er das kann[ich weiß es net])

Wenn es klappt bestatte ich bericht!


Kann mir denn einer sagen warum der Stack da überläuft?? Oder wie kann ich den Stack vergrößern?

Weil der Stack begrenzt ist um Endlosrekusionen abfangen zu können.
Wenn du nun dein Array auf dem Stack anlegst, dann wird der Speicherbereich beim Eintreten in die Funktion auf dem Stack reserviert und er läuft über. Da der Compiler aber die Größe des Arrays kennt, kann er die Kompilierung abbrechen, da das Programm sowieso an der stellen mit EStackOverflow abbrechen würde.

Falls möglich, kannst du dieses Array auch global definieren ... dann kommt's net in den Stack rein und es gibt diesbezüglich keine Probleme.

die Andere Möglichkeit, ist wie schon gesagt wurde ein dynamisches Array ... dafür benötigst du dann allerdings 2-mal SetLength.

Die 3. Variante ist, das du einen Pointer auf diese Struktur generrierst und diesen dann per New mit leben erfüllst

markieren

Delphi-Quellcode:

Type A = array[0..640, 0..480] of word;
 P = ^A;

New(P);

P^[x, y] := ...

Aber nicht vergessen, bei den letzten beiden Varianten bist du für das Freibgeben zuständig.

wenn man das array im private eines Objectes definiert, wird es dann auch auf dem Stack abgelegt wenn das Object erzeugt wird? (wenn nicht könnte man dadurch auch auf die globale verzichten sowie auf das SetLength)

Für die ganzen Pointersachen, wie dynamische Arrays, Klassen, Strings(is ja meistens och nur'n dynamisches Array) wird ganz normal im RAM was reserviert ... der Stack bleibt verschont.

Im Stack landen vorwiegend die (Rück)Sprungadressen und einfachen lokalen Variablen, sowie die Pointer der restlichen lokalen Variablen (dynamisches und klassen)

hmm ich hab das schon als Globale deklariert:

type TBuddha = array[0..640, 0..480] of Cardinal;

var itersr, itersg, itersb : TBuddha;


und diese arrays werden in verschieden Procedure und Funktionen bearbeitet!



Hmm, habe leider noch keine zeit gehabt das mit den Dynamischen zu Probieren aber besser würde mir ehh das mit den Pointern gefallen, da würd ich mir das setlength sparen.

Naja doof das ich nicht einfach nen größeren Stack machen kann.

Zitat von Eichhoernchen:

aber besser würde mir ehh das mit den Pointern gefallen

Beim dyn. Array kümmert ich Delphi um die Freigabe. Bei New/Dispose ist es der Fehler vor dem Bildschirm, der das erledigen muss. Und wir alle wissen, wie unzuverlässig dieser ist.

oder eben statt dem globalen das einfach in die Klasse packen.
also hier her

markieren

Delphi-Quellcode:

[...]
type
  TForm1 = class(TForm)
  [...]
  private
    fYourArray: array[0..640, 0..480] of Cardinal;