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

[Uwe Raabe]

Zitat:

Zitat von kretabiker (Beitrag 1287413)

Wie entdeckt ihr eigentlich solche Neuerungen immer?

Vergleich des Source-Folders mit dem der alten Version?

[himitsu]

Zitat:

Zitat von Der schöne Günther (Beitrag 1287429)

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

Jupp, denn siehe #8. :cry:

Also das ist schon mindestens seit D7 dabei. (vielleicht hatte ich es auch schon in D4 benutzt)


Nja, aus diesem Grund würde ich mir leider nie die Starter-Editionen kaufen können, denn da schon die OH oft sehr leer ist, kann man nur intteressiert in die Quellcodes gucken. :)

[mm1256]

Hallo,

weil meine Frage zum Thema passt, fange ich mal keinen neuen Fred an.

Delphi-Quellcode:

type
  TIntegerRec = record
    i1 : integer;
    i2 : integer;
    s1 : string;
    s2 : string;
  end;
  TIntegerRecArray = array of TIntegerRec;

procedure TForm1.Button1Click(Sender: TObject);
var
  IRA : TIntegerRecArray;
  x: TIntegerRec;
  i: integer;
begin
  IRA := [];
  for i := 1 to 10 do begin
    x.i1 := i;
    x.i2 := i * 100;
    x.s1 := IntToStr(x.i1);
    x.s2 := IntToStr(x.i2);
    IRA := IRA + [x];
  end;
  Edit1.Text := '';
  for i := Low(IRA) to High(IRA) do begin
    x := IRA[i];
    Edit1.Text := Edit1.Text+x.s1+','+x.s2+' ';
  end;
  IRA := []; // muss das sein?
end;

Meine Frage ist, muss das Array geleert werden, um den Speicherplatz freizugeben? Wie verhält es sich, wenn IRA eine globale Variable wäre? Gibt dann die Application beim Beenden den Speicher frei?

[Der schöne Günther]

Wenn eine Applikation endet räumt das OS sowieso den von der Anwendung belegten Speicher ab. Arrays, Records, Interfaces und Strings werden gemanaged- Wenn sie nicht mehr genutzt werden, werden sie abgeräumt.

Wenn du beispielsweise in einer Klasse ein Array hast dass du nicht mehr brauchst wird das Array erst freigegeben wenn das Objekt auch abgeräumt wird. Es sei denn, du setzt es schon vorher, wenn du weißt dass du es nicht mehr brauchst, auf nil.

In deinem Beispiel: Nein, das muss nicht sein. Denn es ist eine lokale Variable die nur in deiner Methode bekannt ist. Endet die Methode, fällt der "Referenzzähler" des Arrays auf Null (niemand kennt das Array) und somit wird es freigegeben.

[mm1256]

Vielen Dank! :thumb:

[himitsu]

Was ich mir aber mal wünschen würde, wäre ein Copy-On-Write bei den dyn. Arrays, so wie man es von Strings kennt ... also daß man das endlich, nach vielen Jahrzehnten, langsam mal repariert.

Delphi-Quellcode:

var
  A, B: TArray<Integer>;

A := [1, 2, 3];
B := A;
A[0] := 4;
ShowMessage(B[0].ToString);

bzw.

Delphi-Quellcode:

var
  A, B: TArray<Char>;
  C, D: string;

A := ['1', '2', '3'];
B := A;
A[0] := '4';

C := '123';
D := C;
C[Low(string)] := '4';  // aka C[1] bei Nicht-ARC

ShowMessage(B[0] + ' <> ' + D[Low(string)]);

[Der schöne Günther]

Also "reparieren" finde ich ziemlich hart. Entweder ist es heute schon zu spät für mich, aber wo sind bitte Arrays überhaupt COW? Googeln brachte jetzt PHP zutage, aber da ich kein PHP kenne konnte ich das nicht überprüfen. Sonst?