Waren Delphi 3 Arrays Fehlertoleranter?

[Popov]

Ich sitze hier an einem alten Programm Delphi 3 Programm und versuche es auf einen neueren Stand zu bringen. Vieles war in Delphi 3 nicht möglich, also versuche ich bei der Gelegenheit einiges zu verbessern. Nun habe ich eine Fehlermeldung die ich noch nicht richtig einordnen kann. Dabei stelle ich mir die Frage ob das bereits im Delphi 3 ein Fehler war oder bei der Neuprogrammierung entstanden ist.

Das Ganze sieht so aus: ich hab in Delphi 3 ein zweidimensionales Array, von [0..10, 0..10]. Natürlich statisch wie in Delphi 3 üblich. Mit einem zweiten eindimensionalen Array [1..5] lese ich fünf Werte in beliebiger Richtung aus. Dabei kann es passieren, daß wenn ich z.B. bei 8 bin und die nächsten 5 Werte weiter lese, ich über die Grenze von 10 bin.

So wie es bisher aussieht störte sich mein Delphi 3 Code nicht dran und las einfach drüber. Jetzt kriege ich eine Zugriffsverletzung. Nun stelle ich mir die Frage ob ich den alten Code nur nicht überblicke, sich bei der Neupogrammierung ein Fehler eingeschlichen hat oder Delphi 3 etwas toleranter war wenn man beim Array drüber las. Oder liegt es daran, daß ich jetzt einen dynamischen Array habe?

Ach so, falsche Werte fielen damals nicht auf, da einiges doppelt gemoppelt war und falsche Werte ignoriert wurden.

Kann es also sein, daß sich Delphi 3 nicht dran störte?

[jaenicke]

Naja, wenn du über die Grenze des Arrays hinaus zugreifst, dann ist doch die Frage was dahinter steht. Und das ist mehr oder weniger Zufall, so dass da schlicht und einfach etwas anderes stehen wird als in Delphi 3. Und wenn du dabei einen Teil einer visuellen Komponente z.B. triffst, gibts eine Zugriffsverletzung.

Deshalb kannst du ja einfach die Bereichsüberprüfung in den Compileroptionen aktivieren, in den meisten Fällen werden dann die Fehler angezeigt statt einer nichtssagenden Zugriffsverletzung.

[Popov]

Ich hab es gerade selbst getestet. Wie es scheint hat das weniger mit Delphi 3 zu tun als mit statischen Arrays. Wie es aussieht kann man bei statischen Arrays drüber lesen, bei dynamischen kommt ein Fehler.

Hier eine kleine Routine für alle die es testen wollen:

Delphi-Quellcode:

const
  x = 9;
  y = 9;

var
  astat: array[0..10, 0..10] of Byte;
  b: Byte;
  adyna: array of array of Byte;

procedure TForm1.Button1Click(Sender: TObject);
begin
  Inc(b);

  Caption := (Format('x: %d, y: %d, b: %d, w: %d', [x, y, b, astat[x + b,y]]));
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  SetLength(adyna, 11, 11);
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  Inc(b);

  Caption := (Format('x: %d, y: %d, b: %d, w: %d', [x, y, b, adyna[x + b,y]]));
end;

Ok, Frage beantwortet. Der Fehler war schon da, nur fiel er früher nicht auf.

[Hawkeye219]

Hallo Popov,

du vermutest ganz richtig - es liegt an den dynamischen Arrays.

Zweidimensionale Arrays werden in Delphi zeilenweise im Speicher abgelegt. Bei statischen Arrays liegen diese Zeilen direkt hintereinander, man kann also prinzipiell ein zweidimensionales Array als ein großes eindimensionales Array betrachten und auch (über Zeiger oder einen TypeCast) so ansprechen.

Bei dynamischen Arrays liegen die einzelnen Zeilen nicht mehr zwangsläufig direkt hintereinander im Speicher, ein Zugriff außerhalb des gültigen Bereichs einer Zeile führt damit zu dem von dir beschriebenen Fehler.

Gruß Hawkeye

[3_of_8]

Genaugenommen tun sie das bei dynamischen sogar nie, denn selbst, wenn die Zeilen direkt hintereinander sind, ist vor jeder Zeile noch die Längenangabe und ich glaube auch noch ein Referenzzähler. Das ist aber natürlich nur nebensächlich.

[Popov]

Naja, Schande über mich, aber es ist das erste Mal, daß ich dynamische Arrays nutze. Bisher kam ich ohne sie aus.

[himitsu]

Wenn alle Arrays einer Ebene gleich groß sind (im dynamischen Array können die ja unterschiedlich sein), dann wäre auch noch sowas möglich:

Delphi-Quellcode:

Var Arr: Array of Array of Irgendwas;

SetLength(Arr, 10, 20);

For i := 0 to Length(Arr) * Length(Arr[0]) - 1 do
  Arr[i div Length(Arr), i mod Length(Arr)] := etwas;