Hallo,

Arrays welche per Wert Parameter übergeben werden, verhalten sich ja trotzdem wie var Parameter. (dh es wird keine Kopie erzeugt)

Wird bei offenen Arrays eine Kopie erzeugt? Muss ich evtl explizit das offene Array als Var Parameter übergeben um keine Kopie zu bekommen?

Mir leuchtet nicht ein, warum ich meinen Array nicht an SetLength übergeben kann...

Mir ist bewusst, das ich hier kein Array-Parameter habe sondern ein Offenes Array-Parameter, aber was kann ich machen,
ohne mir einen Typen des Arrays zu deklarieren.

zusammenfalten · markieren

Delphi-Quellcode:

TMyClass = class
  MyArray : array of TIrgendwas;

begin
  DoSomething(MyArray);
  
  SetLength(MyArray, 10); // Garkein Problem
end;

DOSomething(ParaArray : array of TIrgendwas)
begin
  SetLength(ParaArray, 1); // Inkompatible Typen
end;

Wäre super wenn es genau dafür eine Lösung gibt, sonst könnte es kompliziert werden alles auf  TMyArray : array of TIrgenswas umzustellen...

Grüße

edit:
Wo ich schon mal dabei bin, mir erschließt sich nicht der Sinn, warum wir 2 Array Typen brauchen...

markieren

Delphi-Quellcode:

// Warum ist:
TMyArray = array of TObject;
var
  MyArray : TMyArray

// anders als
var
  MyArray : array of TObject

Zitat von Jonas Shinaniganz:

Muss ich evtl explizit das offene Array als Var Parameter übergeben um keine Kopie zu bekommen?

Nein, ein const reicht völlig aus!

Zitat von Jonas Shinaniganz:

Mir leuchtet nicht ein, warum ich meinen Array nicht an SetLength übergeben kann...

Leuchtet es denn bei var x: array[1..6] of integer ein? Offene Arrays sind doch keine dynamischen, sondern haben ein feste Größe, also kannst Du die Größe auch nicht ändern!

Zitat von Jonas Shinaniganz:

Wo ich schon mal dabei bin, mir erschließt sich nicht der Sinn, warum wir 2 Array Typen brauchen...

Historisch, gab's schon vor Delphi.

hi, danke gamma

Zitat:

Leuchtet es denn bei var x: array[1..6] of integer ein? Offene Arrays sind doch keine dynamischen, sondern haben ein feste Größe, also kannst Du die Größe auch nicht ändern!

Wenn mein MyArray : array of TObject von fester Größe ist, warum kann ich dann Setlength(MyArray, X) aufrufen? Da scheint mir die größe doch variabel?

Ich kann es ja nur nicht in der übergebenen prozedur aufrufen?

edit: Wenn ich mich entscheide, ob ich ein Dynamisches oder Offenes Array brauche, überlege ich dann einfach, ob die Größe variabel oder fix sein wird?

edit2:
Noch hatte ich keine Erleuchtung...

markieren

Delphi-Quellcode:

var
  myarry : array of TObject; // das hier müsste ja ein offenes Array sein
begin
  SetLength(myarry, 10);
  SetLength(myarry, 4);
  SetLength(myarry, Wasauchimmer);
  // funktioniert... und erscheint mir recht dynamisch?
end;

Zitat von gammatester:

Zitat von Jonas Shinaniganz:

Wo ich schon mal dabei bin, mir erschließt sich nicht der Sinn, warum wir 2 Array Typen brauchen...

Historisch, gab's schon vor Delphi.

Um genau zu sein liegt das daran, dass bei Verwendung von array of als Variablentyp jeweils ein neuer Typ angelegt wird. Und damit ist das ein anderer Typ als ein anderswo deklarierter.

Ein offenes Array ist niemals eine Variable, sondern immer ein Parameter.

markieren

Delphi-Quellcode:

var
  Arr: array of integer; //dynamisches Array

procedure MachWas(Arr: array of integer); //offenes Array

Siehe auch http://www.delphibasics.co.uk/RTL.asp?Name=array

Gut, dann habe ich vorher kein "Offenes Array".

Also kann ich das dynamisches Array nur als Referenz übergeben, wenn ich vorher eine Array Typdefinition erstelle. Sonst wird es ein heimlich ein "Offenes Array" naja... merkwürdig.

Danke nochmal.

markieren

Delphi-Quellcode:

type
  tmya = array of integer;
  pmya = ^tmya;


procedure Machwas(p_myarray:pmya);
var
  ......

Manchmal geht mir die Typsicherheit echt auf den Senkel.

Gruß
K-H

Zitat von jaenicke:

Um genau zu sein liegt das daran, dass bei Verwendung von array of als Variablentyp jeweils ein neuer Typ angelegt wird. Und damit ist das ein anderer Typ als ein anderswo deklarierter.

Na ja das ist ja wohl eher ein Nebeneffekt. Der Hauptsinn von offenen Arrays ist doch, daß man Sachen wie zB function Mean(const Data: array of Double): Extended; (aus Math-Unit) implementieren kann, ohne mit Pointern (plus Längenangaben) zu arbeiten zu müssen.

Zitat von gammatester:

Na ja das ist ja wohl eher ein Nebeneffekt. Der Hauptsinn von offenen Arrays ist doch,

Das ist ja kein Sinn, sondern die Art und Weise wie der Compiler intern arbeitet. Der arbeitet nun einmal typsicher und braucht daher einen Typ, auch wenn da "nur" steht array of integer. Also legt er einen neuen lokalen Typen dafür an.

Und da der dann nicht mit einem anderen Typen übereinstimmt, auch wenn er eigentlich gleich aussieht, sind sie nicht kompatibel.

Zitat von jaenicke:

Das ist ja kein Sinn, sondern die Art und Weise wie der Compiler intern arbeitet. Der arbeitet nun einmal typsicher und braucht daher einen Typ, auch wenn da "nur" steht array of integer. Also legt er einen neuen lokalen Typen dafür an.

Ich weiß ehrlich nicht warauf Du eigentlich hinauswillst. Ich habe auf die Frage "Warum gibt es zwei unterschiedliche Typen ..." geantwortet: "Historisch ..."; worauf Du meintest, sagen zu müssen "um genau zu sein ..". Historisch wurden die "Offenen Arrays" in Turbo/Borland Pascal u.a. genau mit dem von Dir bemängelten "Sinn" eingeführt. Das Delphi später dynamische Arrays eingeführt hat, ändert daran nichts. (Sie hätte es natürlich besser machen können, um diese Verwirrung zu vermeiden). Aber lassen wir besser diese ins Off-Topic führende Diskussion ...