Übertrage ein Programm nach Pascal und habe ein Problem ein Mehrfach-Array von einer Procedure A an die nächste Procedure B weiterzuleiten. Ich weiss, dass ich das Problem mit einer eigenen Type- Deklaration lösen könnte, aber ging dies nicht auch noch einfacher? Hier was der Compiler schon in der Procedure A mit "Inkompatible Typen" beanstanded:

zusammenfalten · markieren

Delphi-Quellcode:

PROCEDURE A
var PV : Array[1..3, 1..2]of Extended;
Begin
  B ( PV );
End;

PROCEDURE B ( var PV : Array of Extended );
var I, J : INTEGER;
Begin
For I := 1 to 2 do
  begin
  For J := 1 to 3 do PV[J, I] := 0.0;
  end;
End;

Hallo,
PROCEDURE A wo ist das Semikolon?
var PV : Array[1..3, 1..2]of Extended;

Und nein, es geht nur über das separate Type.

Geht zwar nicht mit Delphi 5 aber mit aktuelleren Versionen so:

zusammenfalten · markieren

Delphi-Quellcode:

PROCEDURE B(var PV: TArray<TArray<Extended>>);
var
  I, J: INTEGER;
Begin
  For I := Low(PV) to High(PV) do
  begin
    For J := Low(PV[I]) to High(PV[I]) do
      PV[J, I] := 0.0;
  end;
End;

PROCEDURE A;
var
  PV: TArray<TArray<Extended>>;
Begin
  SetLength(PV, 3, 2);
  B(PV);
End;

Danke, hoika. Der Mehrfach-Array funktioniert in D5 also doch nur mit der Type-Deklaration, dies im Gegensatz zum Einfach-Arrray.

Ja, Uwe Raabe, wenn ich einmal viel Zeit habe oder wenn die IDE mit D5 gar nicht mehr funktioniert werde ich auf eine neuere Version umstellen ...

Vielen Dank für Eure Hilfe.
Grüsse von MET

Naja, bedingt. "array of Extended" funktioniert leider auch nur sehr bedingt. Im Rückgabewert der Funktion beispielsweise nämlich nicht.
Der Grund, warum das so nicht funktioniert ist, dass es im Grunde (obwohl ähnlich bzw gleich deklariert) drei Arten von Arrays für den Compiler gibt:

1. Statische Arrays, die auf dem Stack abgelegt werden können, da ihre Größe zur Kompilierzeit bereits feststeht
2. (Einfache) dynamische Arrays, deren Größe bei der Erzeugung festgelegt wird und die somit auf dem Heap gespeichert werden müssen; sie verhalten sich ähnlich wie Zeiger auf statische Arrays mit der besonderheit, dass sie selber die Eigenschaften eines Arrays (Referenzzählung, Typpenprüfung, ...) besitzen
3. (Offene) Parameter-Arrays, die zwar immer dynamisch sein müssen, dafür aber auch "untypisiert" sein dürfen*

*was sie natürlich nur "scheinbar" sind. (In Wahrheit sind es offene arrays von TVarRec-Objekten)

Offene Arrays sind nicht exakt das gleiche wie dynamische Arrays und somit auch nur teilweise kompatibel. Die Konvertierung von einem dynamischen Array in ein offenes Array verläuft bei der Parameterübergabe implizit.
Offene Arrays müssen eindimensional sein. Es sind intern keine "arrays" sondern Zeiger auf Records, in denen der Zeiger auf das erste Element, sowie die Länge gespeichert ist. Hier sind wir auch schon bei dem Haken: Es gibt keinen Support für die Dimensionen.
Wenn du gezielt willst, dass keine offenen Arrays erzeugt werden, sondern echte (dynamische) arrays übergeben werden, dann musst du einen expliziten Typen dafür deklarieren. Bei "array of Extended" denkt der Compiler, du wolltest einen offenen Array-Parameter deklarieren. Bei "TArray<Extended>" oder "TExtendedArray" weiß er, dass es dieser spezifische Typ sein soll (nämlich ein dynamisches Array mit Extended-Werten). Beim Funktions-Ergebnistyp versucht er dies auch, allerdings können offene Arrays nicht zurückgegeben werden, weshalb er einen Fehler anzeigt. Hier müsstest du immer den Alias benutzen.

Entschuldigung, falls ich dich verwirrt habe. Nur, falls es dich im Detail interessiert, warum das so nicht geht.