Dynamische Arrays (mal wieder)

[Namenloser]

Zitat von DeddyH:

Es gibt noch array of const, aber ob das damit so funktioniert .

array of const und generell array of irgendwas bei Prozedurparametern sind nicht dasselbe wie „normale“ dynamische Arrays. Ich meine, die wären deshalb auch Read-Only und das interne Format ist glaube ich auch irgendwie anders als bei dynamischen Arrays (welche, wenn ich mich nicht irre, auch ein neueres Konstrukt sind als die array-Parameter).

Was z.B. auch nicht geht:

Delphi-Quellcode:

function Foo(A: Array of Integer): Array of Integer;
begin
  Result := A;
end;

Die einzige Möglichkeit ist, elementweise umzukopieren.

Bis vor ein paar Jahren dachte ich (ich glaube die Information hatte ich aus aus meinem ersten Delphi-Buch?), dass das einfach daran läge, dass der Compiler nicht „weiß“, dass die beiden Array-Deklarationen äquivalent sind und das der Grund wäre, weshalb man bei so etwas immer einen extra Typen deklarieren muss. Aber ich hatte mir irgendwie mal den Assembler-Code angesehen und in der System.pas gewühlt und es war völlig anders... was wohl daran liegt, dass array of irgendwas bei Parametern immer noch die alte Compiler-Magic (wie sie von Format() und Co. verwendet wird) ist, während die gleiche Notation beim Result für die „neuen“ dynamischen Arrays (ab Delphi 4) steht. Die beiden sind nicht kompatibel.

Das aber nur am Rande.

Generics wären wohl das beste, oder du musst für jeden Typen die Prozedur überladen:

Delphi-Quellcode:

function AllocateNextFreeField(A: TIntArray): Integer; overload;
begin
  SetLength(A, Length(A)+1);
  Result := high(A);
end; 

function AllocateNextFreeField(A: TFloatArray): Integer; overload;
begin
  SetLength(A, Length(A)+1);
  Result := high(A);
end;

̀function AllocateNextFreeField(A: TStringArray): Integer; overload;
begin
  SetLength(A, Length(A)+1);
  Result := high(A);
end; 

...

(Nebenbei, den Code kannst du abkürzen, wie du hier siehst)

[himitsu]

Jupp, "dynamische", bzw. noch nicht definierte Typen mit den Generics,
oder eben als überladene Methoden,
aber sonst wird das eher eine Bastelstunde.


function AllocateNextFreeField(const TheArray): Integer; und dann intern über die RTTI rummurksen.

Dann wäre das über die Generics einfacher, da dieses sich dann um die RTTI kümmert.
function TMyClass.Foo<T>(const A: TArray<T>): Integer; oder function TMyClass<T>.Foo(const A: TArray<T>): Integer;

[DelTurbo]

Erstmal vielen dank an alle. Ich verusche das umzusetzen und werde bericht, wie immer.

[Namenloser]

Zitat von himitsu:

Dann wäre das über die Generics einfacher, da dieses sich dann um die RTTI kümmert.

Und das vor allem zur Compile-Zeit ... oder?

[himitsu]

Zitat von Namenloser:

Und das vor allem zur Compile-Zeit ... oder?

Jupp.
Genauso, wie bei den überladenen Methoden.

Wenn man das in einer Methode macht und dann erst in der Prozedur den Typ prüft, dann bekommt man auch erst zur Laufzeit mit (hoffentlich schnell), wenn etwas nicht stimmt.

[DelTurbo]

Zitat von namenloser:

Delphi-Quellcode:

function allocatenextfreefield(a: Tintarray): Integer; overload;
begin
  setlength(a, length(a)+1);
  result := high(a);
end; 

function allocatenextfreefield(a: Tfloatarray): Integer; overload;
begin
  setlength(a, length(a)+1);
  result := high(a);
end;

̀function allocatenextfreefield(a: Tstringarray): Integer; overload;
begin
  setlength(a, length(a)+1);
  result := high(a);
end; 

...

(nebenbei, den code kannst du abkürzen, wie du hier siehst)

Hi, leider klappt es nicht. Bei der zeile SetLength bekomme ich E2008 Inkompatible Typen zurück. Auch wenn ich folgendes versuche.

function allocatenextfreefield(a: array of Tintarray): Integer; overload;

Ich versuche es mit folgendem Typ.

type
TMp3Data = record
InUse :Boolean;
Playing :Boolean;
FName :String;
Artist :String;
Title :String;
Dauer :Integer;
BitRate :Integer;
end;

[DeddyH]

Delphi-Quellcode:

type
  TMp3Data = record
    InUse :Boolean;
    Playing :Boolean;
    FName :String;
    Artist :String;
    Title :String;
    Dauer :Integer;
    BitRate :Integer;
  end;

  TTestArray = array of TMp3Data;

function AllocateNextFreeField(var Arr: TTestArray): integer;
begin
  SetLength(Arr, Length(Arr) + 1);
  Result := High(Arr);
end;

Klappt einwandfrei unter Delphi 7.

[himitsu]

Erstmal fehlte da ein VAR, denn das Array soll ja verändert werden.
function allocatenextfreefield(var a: Tintarray): Integer; overload;

Und das hat array of ... als Patrameter eine besondere Bedeutung, denn das definiert einen "speziellen" Array-Parameter, aber der ist hier nicht so wichtig.

Du brauchst erstmal einen VAR-Parameter und das ist sowieso nicht mit dem Array-parameter kompatibel.

Außerdem mußt du bei Parameter, auch für kompatible Typen sorgen, also der Array-Typ muß vorher definiert und überall verwendet werden, da diese Typen sonst nicht kompatibel sind, auch wenn sie "gleich aussehen".
Einzige Ausnahme ist die generische Variante via TArray<...> .

[Namenloser]

Zitat von himitsu:

Erstmal fehlte da ein VAR, denn das Array soll ja verändert werden.
function allocatenextfreefield(var a: Tintarray): Integer; overload;

Braucht man nicht unbedingt, da Arrays genau wie Objekte Referenztypen sind. Copy-On-Write wie bei Strings gibt es bei Arrays auch nicht. Somit wird immer das Original-Array modifiziert. Zumindest bin ich mir da zu 95% sicher.

Besser verständlich ist es aber mit var , da gebe ich dir recht.

@DelTurbo: Zeig mal deinen kompletten Code, also die Typendeklaration und deine Funktion. Eigentlich muss das funktionieren.

[himitsu]

Zitat von Namenloser:

Braucht man nicht unbedingt, da Arrays genau wie Objekte Referenztypen sind. Copy-On-Write wie bei Strings gibt es bei Arrays auch nicht. Somit wird immer das Original-Array modifiziert. Zumindest bin ich mir da zu 95% sicher.

Jain. Ja, es sind Referenztypen, aber es ist wie beim String, was ja auch ein Referenztyp ist, bzw. ein String (nicht ShortString oder WideString) ist sogar ein aufgemotztes array of char .
Und da ist es wie bei Integer und Co. ... man braucht das VAR.