Dynamische Arrays in XE7

[Neutral General]

Hallo,

Hier zeigt Marco Cantu was mit dynamischen Arrays in DelphiXE7 möglich ist.
Habe da aber ein paar Probleme...

Delphi-Quellcode:

var arr1: Array of Integer;
    arr2: Array of Integer;
begin
  arr1 := [1, 2, 3];     // geht
  arr2 := [4, 5, 6];      // geht

  arr1 := arr1 + arr1;      // geht
  arr1 := arr1 + [4, 5, 6];  // geht

  arr1 := arr1 + arr2;      // "Inkompatible Typen"
  arr1 := arr2 + [1, 2, 3]; // "Inkompatible Typen"
end;

Das Initialisieren der Arrays ist ja super aber das Aneinanderhängen wurde ja dann von der vorteilhaften Seite gezeigt. Wenn ich keine 2 verschiedenen dyn. Arrays aneinanderhängen kann
dann ist das Feature irgendwie fast unbrauchbar.

Oder bin ich nur zu Blöd und übersehe was?

[Klaus01]

Du beiden Arrays müssen von gleichen Type sein.

Delphi-Quellcode:

type
  TDynIntArray = Array of Integer;

var
  arr1: TDynIntArray;
  arr2: TDynIntArray
...

Grüße
Klaus

[Daniel]

Mach' ma TArray<integer> aus dem Datentyp.

[Medium]

Das war doch schon immer so, z.B. bei dyn. Arrays als Parameter.

Delphi-Quellcode:

type
  TDynIntArray = array of Integer;

var
  a, b: TDynIntArray;
begin
  a := a + b;

Das sollte klappen. Mit dem offenen Array sehe ich aber zumindest jetzt gerade keinen tollen Weg, ausser ein Cast der Art TDynIntArray([1, 2, 3]) geht. Das weiss ich mangels XE7 aber nicht.

[Neutral General]

Nagut, dann hat Embarcadero ja nochmal Glück gehabt
So funktionierts, danke

[himitsu]

Array of Xyz deklariert einen "neuen" Array-Typen. (hier muß man aufpassen, denn als Methoden-Parameter hat das nochmal eine ganz andere Bedeutung -> offerner Array-Parameter)
Diese Arrays sind zwar "gleich", aber nicht identisch/kompatibel -> haben jeweils ihre eigene RTTI-Definition.
Das ist wie mit type TMyClassA = class end; TMyClassB = class end; , welches nicht die "selbe" Klasse ergibt, obwohl es "gleich" aussieht.


TArray<Xyz> ist die generische Version des Array of Xyz , also intern das Selbe, nur sorgen die Generics dafür, daß alle TArray<Xyz> im Programm (im selben Binary -> EXE/DLL) dem "selben" Typen entsprechen.


PS: Auch schon vor den Generics war das Problem bekannt, drum gibt es Typen ala TIntegerDynArray.

[Neutral General]

Vom Prinzip her kenn ich die Problematik/den Hindergrund im Zusammenhang mit Parametern.
Aber habe eben als ichs getestet habe nicht so weit gedacht.

[himitsu]

Delphi-Quellcode:

type
  //TIntegerDynArray = array of Integer;  // siehe Unit Types
  //TArray<T> = array of T;  // siehe Unit System

  A = TIntegerDynArray;  // Alias
  B = type TIntegerDynArray;  // neuer Type, aber kompatibel zu TIntegerDynArray
  C = array of Integer;  // eigener Typ
  D = TArray<Integer>;  // Alias

PS: siehe mein letztes PS


Ich frage mich nur, warum diese Tro... keiner auf die saudämliche Idee gekommen ist und die vordefinierten Typen der Types.pas oder des TBytes auf den generischen Typen umzustellen (als Alias).
Nur die von TidBytes waren so intelligent.

[kretabiker]

Zitat:

PS: Auch schon vor den Generics war das Problem bekannt, drum gibt es Typen ala TIntegerDynArray.

Sehr schön - und DAS sagt ihr mir erst jetzt?! Seit wievielen Jahren gibt es den Typ schon, verflixte Axt? Dann kann ich ja mal durch meine Sourcen sausen und meine geliebte Type-Definition TIntArray entfernen - lang lebe Suchen/Ersetzen...

Wie entdeckt ihr eigentlich solche Neuerungen immer? Und wieso ich nicht? *schmoll* (immerhin: die Existenz von Generics habe ich mitbekommen)

[Der schöne Günther]

Tu dir den Gefallen und nimm gleich TArray<Integer> und nicht TIntegerDynArray oder wie es heißt