Beliebiges Array übergeben

[dominikkv]

Hallo,

ich habe folgende Arrays:

Delphi-Quellcode:

type
  TMeinArray1: array of TMeinObjekt1;
  TMeinArray2: array of TMeinObjekt2;
  TMeinArray3: array of TMeinObjekt3;

TMeinObjekt1, TMeinObjekt2 und TMeinObjekt3 erben alle von TPersistent, mehr haben sie nicht gemeinsam.

Mein Problem ist, ich möchte eine Funktion schreiben, die Arrays von diesen Typen als Parameter entgegennimmt.
Soll heißen das hier sollte möglich sein:

Delphi-Quellcode:

var
  meinArray1: TMeinArray1;
  meinArray2: TMeinArray2;
  meinArray3: TMeinArray3;
begin
  // Initialisiere die drei arrays und fülle sie mit Werten...

  MeineTolleFunktion(meinArray1);
  MeineTolleFunktion(meinArray2);
  MeineTolleFunktion(meinArray3);
end;

Mein Versuch sieht so aus:

Delphi-Quellcode:

function MeineTolleFunktion(const Parameter): Boolean;
var
  I1        : Integer;
  MeinObjekt: TObject;
begin
//  for I1 := 0 to Length(Parameter) - 1 do  // Length(Parameter) geht natürlich nicht
//    begin
//      MeinObjekt := Parameter[I1];  // Parameter[I1] geht natürlich nicht
//      MacheWasMit(MeinObjekt);
//    end;
end;

Das ganze kompilliert schon mal, nur möchte ich jetzt, wie als Kommentar angedeutet, auf das Array zugreifen...

Hat jemand eine Idee, wie man sowas machen könnte? Oder vielleicht einen ganz anderen Ansatz?


Grüße
Dominik


Edit:// Delphi 7

[sirius]

Du nimmst statt Arrays eine Klasse namens TObjectList.

[Panthrax]

Delphi-Quellcode:

type
  PMeinArray = ^TMeinArray;
  TMeinArray = array of TPersistent;

{ Variante 1 }

function MeineTolleFunktion(const Parameter: PMeinArray): Boolean; overload;
begin
  Result := False;
end;

{ Variante 2 }

function MeineTolleFunktion(const Parameter: TMeinArray): Boolean; overload;
begin
  Result := False;
end;

function MeineTolleFunktion(const Parameter: TMeinArray1): Boolean; inline; overload;
var
  P: TMeinArray absolute Parameter;
begin
  Result := MeineTolleFunktion(P);
end;

var
  MeinArray1: TMeinArray1;

begin
  MeineTolleFunktion(@MeinArray1); // Variante 1
  MeineTolleFunktion(MeinArray1);  // Variante 2
end.

Ich würde Variante 2 nehmen, oder von TList ableiten (Variante 3):

Delphi-Quellcode:

{ Variante 3}
type
  TPersistentList = class(TList) // ggf. von TObjectList ableiten
    // Typsicherheit herstellen für TPersistent
  end;

  TMeinObjekt1List = class(TPersistentList)
    // Typsicherheit herstellen für TMeinObjekt1
  end;

function MeineTolleFunktion(const Parameter: TPersistentList): Boolean; overload;
begin
  Result := False;
end;

[Aphton]

Delphi 2007 unterstützt noch keine Generics, oder?

[Bummi]

wenn alle MeinObjektx von einer Basisklasse MeinObjekt abgeleitet sind kann man ja auch wenn man es nie braucht

TMeinArray= array of TMeinObjekt;

deklarieren und wie folgt verfahren ...

Delphi-Quellcode:

function MeineTolleFunktion(const Parameter: TMeinArray): Boolean; overload;
begin
   if High(Parameter)>-1 then
      if Parameter[0] is TMeinObjekt1  then Showmessage('Nr1')
      else Showmessage('Keine Nr 1');


  Result := False;
end;

procedure TForm2.Button1Click(Sender: TObject);
var
 vArray1:TMeinArray1;
 vArray2:TMeinArray2;
begin
   SetLength(vArray1,1);
   vArray1[0] := TMeinObjekt1.Create;
   MeineTolleFunktion(TMeinArray(vArray1)) ;
   vArray1[0].Free;

   SetLength(vArray2,1);
   vArray2[0] := TMeinObjekt2.Create;
   MeineTolleFunktion(TMeinArray(vArray2)) ;
   vArray2[0].Free;
end;

[himitsu]

Haben diese TMeinObjektX einen gemeinsamen Vorfahren? (wenn nicht, dann TObject)

Versuch mal einen offenen Array-Parameter
function MeineTolleFunktion(Parameter: array of TMeinObjektVorfahr): Boolean; Falls das ncht geht, dann wäre es "sicherer", wenn du 3 überladene Prozeduren erstellt, also je Typ eine Version.
Bei deiner Variante, könntest du die Arrays in ein array of TObject casten, aber wenn jemand was Anderes übergibt, dann knallt es ganz schnell mal.

[dominikkv]

Danke für die vielen Antworten!

Zitat von sirius:

Du nimmst statt Arrays eine Klasse namens TObjectList.

Danke, natürlich mache ich das. Die erleichtert mir auch das Leben beim Freigeben Das ich das nicht gleich gesehen habe... aber manchmal wächst halt so ein Code mit der Zeit und man wird blind für radikalere Änderungen

Zitat von Panthrax:

Delphi-Quellcode:

begin
  MeineTolleFunktion(@MeinArray1); // Variante 1
  MeineTolleFunktion(MeinArray1);  // Variante 2
end.

Variante 1 will ich nicht, und für Variante 2 müsste ich für jedes Array eine eigene Funktion basteln... aber cooler Ansatz
Variante 3 geht in die Richtung mit der TObjectList

Zitat von Aphton:

Delphi 2007 unterstützt noch keine Generics, oder?

Auf jeden Fall gilt dies für Delphi 7

Zitat von Bummi:

wenn alle MeinObjektx von einer Basisklasse MeinObjekt abgeleitet sind kann man ja auch wenn man es nie braucht

TMeinArray= array of TMeinObjekt;

deklarieren und wie folgt verfahren ...
MeineTolleFunktion(TMeinArray(vArray1)) ;

Würde gehen, will ich aber nicht

Zitat von himitsu:

Haben diese TMeinObjektX einen gemeinsamen Vorfahren? (wenn nicht, dann TObject)

TPersistent

Zitat von himitsu:

Versuch mal einen offenen Array-Parameter
function MeineTolleFunktion(Parameter: array of TMeinObjektVorfahr): Boolean;

Geht leider nicht

Zitat von himitsu:

Falls das ncht geht, dann wäre es "sicherer", wenn du 3 überladene Prozeduren erstellt, also je Typ eine Version.
Bei deiner Variante, könntest du die Arrays in ein array of TObject casten, aber wenn jemand was Anderes übergibt, dann knallt es ganz schnell mal.

Leider sind das nicht nur 3 Arrays, sondern beliebig viele (über XSLT generiert), darum habe ich eine allgemeine Lösung gesucht.

Nochmals vielen Dank für eure Antworten