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

Delphi-Quellcode:

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

Delphi-Quellcode:

TDynIntArray([1, 2, 3])

geht. Das weiss ich mangels XE7 aber nicht.

[Neutral General]

Nagut, dann hat Embarcadero ja nochmal Glück gehabt :twisted: :mrgreen:
So funktionierts, danke :)

[himitsu]

Delphi-Quellcode:

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

Delphi-Quellcode:

type TMyClassA = class end; TMyClassB = class end;

, welches nicht die "selbe" Klasse ergibt, obwohl es "gleich" aussieht.

Delphi-Quellcode:

TArray<Xyz>

ist die generische Version des

Delphi-Quellcode:

Array of Xyz

, also intern das Selbe, nur sorgen die Generics dafür, daß alle

Delphi-Quellcode:

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. :stupid:

[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 :stupid:


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). :wall:
Nur die von TidBytes waren so intelligent. :thumb:

[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 ;-)