n00b-frage zu records/arrays/typecasting

[Dulcet Airman]

Hallo

Ich arbeite zwar schon eine weile mit Delphi aber ich hab noch nicht so den Durchblick bei der Typisierung, deswegen diese (möglichweise blöde) Frage:

Kann ich ein Feld aus unterschiedlichen Arrays (unterschiedliche Records) vergleichen?
Konkret soll das bedeuten dass eine Funktion einen beliebigen Array annehmen soll und darin ein bestimmtes Feld kontrollieren soll (welches immer da ist) während die anderen egal sind.

Pseudocode:

Delphi-Quellcode:

type
  rRec1 = record 
            foo:byte;
            flag:boolean;
          end;
  rRec2 = record 
            bar:string;
            flag:boolean;
          end; 

function hasFlag(aData:array):boolean;

var
arrayA:array[0..12] of rRec1;
arrayB:array[0..100] of rRec2;

implementation

//irgendein flag auf true?
function hasFlag(aData:array):boolean;
var x:cardinal;
begin
  result := false;
  for x := low(aData) to high(aData) do
    if  aData[x].flag = true then
    begin
      result := true;
      break;
    end;
end;

das ganze geht natürlich nicht denn ich weiss nicht was ich als Typ for den Parameter aData angeben soll. irgendwie geht da nichts und typecasting ist anscheinend auch nicht möglich da so ein record nicht gerade sehr flexibel ist.

mit Objekten/Klassen wär das wohl einfacher, da gibts ja die Vererbung. der Code ist aber mit Records gemacht da dies bisher ausreichte.

Kann man das irgendwie auch sonst elegant lösen? Denn ich will schon bei den arrays bleiben, auch wenn es nicht optimal ist. Die ganze Applikation baut drauf auf. Sonst müsste ich halt eine Schlaufe für jeden einzelnen Array schreiben.

Dazu kommt dass ich sonst viel mit PHP mache und daher gewöhnt bin dass man mit array so ziemlich alles erdenkbare machen kann.

Dulcet Airman

[H4ndy]

Du musst explizit Typen erstellen, damit du Arrays als Parameter nutzen kannst:

Delphi-Quellcode:

type
  rRec1 = record
            foo:byte;
            flag:boolean;
          end;
  rRec2 = record
            bar:string;
            flag:boolean;
          end;

  TMyArrayA = array [0..12] of rRec1;
  TMyArrayB = array [0..100] of rRec2;
  // damits dynamisch wird, so machen (SetLength nicht vergessen):
  {
  TMyArrayA = array of rRec1;
  TMyArrayB = array of rRec2;
  }
function hasFlag(aData:array):boolean;

var
arrayA: TMyArrayA;
arrayB: TMyArrayB;

implementation

// Das hier im OnCreate oder so einfügen, falls du die dynamischen Array oben nutzt:
{
SetLength(arrayA, 13); // entspricht array [0..12]
SetLength(arrayB, 101); // entspricht array [0..100]
}

//irgendein flag auf true?
function hasFlag(aData: TMyArrayA):boolean; overload;
var x:cardinal;
begin
  result := false;
  for x := low(aData) to high(aData) do
    if  aData[x].flag = true then
    begin
      result := true;
      break;
    end;
end

function hasFlag(aData: TMyArrayB):boolean; overload;
var x:cardinal;
begin
  result := false;
  for x := low(aData) to high(aData) do
    if  aData[x].flag = true then
    begin
      result := true;
      break;
    end;
end;

Soweit ich weiss, dürfte ein Typecast unter den Recordtypen nicht funktionieren,
deshalb musst du überladene Prozedureen schreiben, damit du *bequem* prüfen kannst.
(Diese ist dann mit hasFlag() aufrufbar und nimmt TMyArrayA als auch TMyArrayB an)