Dynamische Arrays (mal wieder)

[DelTurbo]

Hi,
ich arbeite mit Dynamischen Arrays. Um einen neuen "Slot" zu bekommen habe ich eine Funktion. Nun habe ich aber mehrer Dynamische Arrays. Leider alles verschieden Typen. Mal Integer, mal Strings, mal Records.

Ich dachte nun daran GetNextFreeField das Array zu übergeben. Aber man muss ja einen Typ angeben. z.b. GetNextFreeField(var ar:Array of Strings):Integer;
Damit kann ich ja dann wieder kein anderes Array vergrössern.

Nun zu miener Frage. Geht das überhaupt, das man z.b. nur GetNextFreeField(var ar:Array):Integer; irgendwie angeben kann? Also quasi ohne Typ.

Vielen dank im voraus

Delphi-Quellcode:

function GetNextFreeField:Integer;
var
   i         :Integer;
begin
    if KData=nil then begin
      SetLength(KData,1);
    end else begin
      SetLength(KData,high(KData)+2);
    end;
    Result:=high(KData);
end;

[DeddyH]

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

[mkinzler]

Richt nach Generics

[DeddyH]

Das war auch mein erster Gedanke, allerdings steht im Profil Delphi 2007.

[Namenloser]

Zitat:

Zitat von DeddyH (Beitrag 1236873)

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

Delphi-Quellcode:

array of const

und generell

Delphi-Quellcode:

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

Delphi-Quellcode:

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.

Delphi-Quellcode:

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.

Delphi-Quellcode:

function TMyClass.Foo<T>(const A: TArray<T>): Integer;

oder

Delphi-Quellcode:

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:

Zitat von himitsu (Beitrag 1236883)

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:

Zitat von Namenloser (Beitrag 1236930)

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:

Zitat von namenloser (Beitrag 1236880)

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.

Delphi-Quellcode:

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.

Delphi-Quellcode:

function allocatenextfreefield(var a: Tintarray): Integer; overload;

Und das hat

Delphi-Quellcode:

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

Delphi-Quellcode:

TArray<...>

.

[Namenloser]

Zitat:

Zitat von himitsu (Beitrag 1237103)

Erstmal fehlte da ein VAR, denn das Array soll ja verändert werden.

Delphi-Quellcode:

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

Delphi-Quellcode:

var

, da gebe ich dir recht.

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

[himitsu]

Zitat:

Zitat von Namenloser (Beitrag 1237107)

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

Delphi-Quellcode:

array of char

.
Und da ist es wie bei Integer und Co. ... man braucht das VAR.

[Namenloser]

Ok, du hast Recht, aber nur, weil

Delphi-Quellcode:

SetLength

im Code vorkommt. Eigentlich logisch, dabei wird ja neuer Speicher reserviert und dadurch kann sich der Zeiger ändern...

Aber ansonsten geht das:

Delphi-Quellcode:

type 
  TIntArray = array of integer;

procedure Foo(A: TIntArray);
begin
  A[0] := 2;
end;

var
  A: TIntArray;
begin
  SetLength(A, 1);
  A[0] := 1;
  WriteLn(A[0]); // 1
  Foo(A);
  WriteLn(A[0]); // 2
  ReadLn;
end.

[himitsu]

Es geht aber auch nur, weil die das CopyOnWrite bei diesen dynamischen Arrays "kaputt" ist.

Im Prinzip wird beim Entritt in diese Methode, da kein CONST, die Referenzzählung erhöht.
Beim Schreibzugriff auf das Feld müsste aber gemerkt werden, daß hier RefCount <> 1 ist und somit müsste vor dem Schreibzugriff eine Kopie erstellt werden, wo dann erst reingeschrieben wird.

Und ich hoffe immernoch, daß dieser Fehler, auch nach jahrzehnten, irgendwann mal repariert wird,
wobei ich jetzt nicht sagen kann, ob er das nicht schon wurde ... zumindestens in den Compilern für OSX, iOS und Android.

Delphi-Quellcode:

var
  A, B: TIntegerDynArray;
begin
  SetLength(A, 1);
  A[0] := 1;
  B := A;  // B := Copy(A);
  B[0] := 2;
  WriteLn(A[0], ' ', B[0]); // 2 2
  ReadLn;
end.

Mit dem Copy-Bugfix "1 2".

[himitsu]

*deleted*

[DelTurbo]

Also, das von DeddyH klappt soweit. Ich weiß leider nicht wie ich nun auf das Array zugreifen soll. So wie "früher" scheint es wohl nicht mehr zu gehen. Ich habe quellcode etwas gekürtz, da sonst die seite viel zu lange war und man die "richtigen/falschen" stellen suchen musste.

Ich habe das nun so gemacht:

Delphi-Quellcode:

interface

uses ........

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

    Mp3Infos    = array of TMp3Data;
   
    function GetFreeMP3DField(var ary: Mp3Infos):Integer; overload;
   
[snip]

implementation

[snip]
function GetFreeMP3DField(var ary: Mp3Infos):Integer; overload;
var
   i   :Integer;
begin
    if ary=nil then begin
      SetLength(ary,1);
    end else begin
     SetLength(ary,high(ary)+2);
   end;
    Result:=high(ary);
end;
[snip]

      for i:=low(Mp3Infos) to high(Mp3Infos) do begin  // H2135 FOR oder WHILE Schleife wird nicht durchlaufen - gelöscht
         if ( Mp3Infos[i].InUse ) then begin          // E2029 '(' erwartet, aber '[' gefunden
[snip]

Vorher stand einfach Mp3Infos:Array of TMp3Data; unter var.

Nochmals danke im voraus für eure hilfe.

[himitsu]

Zitat:

Zitat von DelTurbo (Beitrag 1237145)

Delphi-Quellcode:

      for i:=low(Mp3Infos) to high(Mp3Infos) do begin  // H2135 FOR oder WHILE Schleife wird nicht durchlaufen - gelöscht
         if ( Mp3Infos[i].InUse ) then begin          // E2029 '(' erwartet, aber '[' gefunden

Ähhhhhh, willst du nun den Typ oder die Variable durchlaufen?

(vielleicht wäre es direkt aufgefallen, wenn du Typen auch mit dem allseits anerkannten Prefix versiehst)

[DelTurbo]

Nicht nur durchlaufen. Auch etwas zuweisen. Sonst bräuchte ich das ja nicht. Ich will das array ja nicht nur vergrössern, sondern auch daten darin ablegen.

[himitsu]

Den Inhalt einer Variable und nicht des Typs.

[DelTurbo]

Erstmal Sorry. Also geht das garnicht was ich vorhabe? Und das mit den Generics habe ich ehrlich gesagt nicht kapiert. Würde das damit gehen?

Wenn ich demnächst nochmal so komplizierte fragen habe, werde ich direkt den Quellcode mit reinpacken. Ich wusste aber nicht das das so ein riesen ding wird. Ich dachte nur ich hätte irgendwie die Syntax falsch.

[himitsu]

2007 = noch keine Generics

[DelTurbo]

Also ist das nicht möglich, was ich vorhatte. Schade. Dann mache ich weiterhin für jedes Array ne eigene Sub.

Trotzdem danke

[DelTurbo]

Ich habe abschließend noch 3 fragen.

1. Wozu kann ich ein Dynamisches Array vergrössern (mit den sachen von DeddyH) wenn ich danach nicht drauf zugreifen kann.

oder

2. Sind einfach nur meine zugriffe auf dieses Array falsch. Wenn ja, wie würden die richtig aussehen.

3. @himitsu, was meinst in meinem beispiel mit "allseits anerkannten Prefix"? Weil, wenn ich das weiß, kann ich in zukunft damit arbeiten.

Vielen dank im voraus

[Klaus01]

.. etwas OT

Was zwingt Dich dyn. Array zu verwenden?

Wenn Du Listen (TList, TObjectList) verwenden würdest
könntest Du auf das vergrössern, verkleinern verzichten.
Das würde die Listen für Dich erledigen.

Grüße
Klaus

[DeddyH]

Nochmal: nicht Typ und Variablen verwechseln. Das hier geht bei mir unter Delphi 2007 ohne Probleme:

Delphi-Quellcode:

type
  TDingens = record
    SomeString: string[10];
    SomeInt: integer;
  end;

  TDingensArray = array of TDingens;

...

function GetNextFreeField(var DingensArray: TDingensArray): integer;
begin
  SetLength(DingensArray, Length(DingensArray) + 1);
  DingensArray[High(DingensArray)].SomeInt := Length(DingensArray);
  Result := High(DingensArray);
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  Dingens: TDingensArray;
  i: integer;
begin
  GetNextFreeField(Dingens);
  GetNextFreeField(Dingens);
  GetNextFreeField(Dingens);
  (* Zugriff auf die Variable und nicht auf den Typ TDingensArray *)
  for i := Low(Dingens) to High(Dingens) do
    ShowMessage(IntToStr(Dingens[i].SomeInt));
  Dingens := nil;
end;

[DelTurbo]

Uff,
also manchmal hab ich echt ein Brett vorm Kopf. Ich danke dir DeddyH für deine Geduld mit so einem wir mir :thumb: