Parameter mit multiplen Typen

[Andreas L.]

Hallo,

ich würde gerne wissen ob es eine Möglichkeit gibt, einen Parameter einer Routine mit mehreren Daten-Typen auszustatten? Die einzige Option die mir einfällt, wäre, die Routine zu überladen.

In PHP kann man z. B. so etwas machen:

Code:

function Test(string|bool $AParam1) {
  // ...
}

Bei dieser Funktion könnte man nun entweder einen String oder einen Boolean-Wert für "AParam1" übergeben. Gibt es so etwas wie diesen |-Operator auch in Delphi? Oder muss ich das zwangsläufig wie folgt angehen:

Delphi-Quellcode:

  function Test(AParam1: String): String; overload;
  function Test(AParam1: Boolean): String; overload;

Oder seht ihr noch andere Möglichkeiten?

Schöne Grüße,
Andreas Lauß

[LoZe]

wie wäre es mit einem TObject?

Delphi-Quellcode:

function Test(AParam1: TObject): String;
begin
  if AParam1 is TOBJ1 then
  begin
    //
  end;
  if AParam1 is TOBJ2 then
  begin
    //
  end;
end;

natürlich mehr Aufwand alle Klassen anzulegen etc...

[QuickAndDirty]

Du kannst einen typlosen paramater verwenden
siehe dazu die Move Prozedur.
procedure Move(const Source; var Dest; Count: Integer); _
Oder TStream read Methode
function TStream.Read(var Buffer; Count: Longint): Longint; Du bekommst dann ein Stückspeicher, aber du musst dich vollständig selbst darum kümmern wie du es behandelst.... wenn du es nur verschlüsseln oder bewegen willst es aber ideal.

Dann gäbe es noch den Variant typ als paramaeter. Da kann man quasi alles übergeben.
Siehe die Locate Methode von TDataset
function TFDDataSet.Locate(const AKeyFields: string; const AKeyValues: Variant; AOptions: TLocateOptions = []): Boolean; _
Wenn du die Auswahl an möglichen Typen kennst, dann kannst du eventuell auch mit einem Varianten Record arbeiten.

Delphi-Quellcode:

type
    TFahrzeugList = (Irgendeins, PKW, LKW, Bus, Motorad, Zug);
    TFahrzeug = record
    case Fahrzeug: TFahrzeugList of
      PKW: (MaxSpeed: Integer;
            Cabrio:Boolean;
            DieselFuel:Boolean;
           );
      LKW: (MaxTonage: Single;
            Trailer:Boolean;
           );
      Bus: (Travelers:Integer;
            Toilet:Boolean;
           );
      Motorad: (Speed: integer;
                Sidecar:Boolean;
                HP:integer;
               );
      Zug: (Passengers:integer;
            Cars:integer;
            Cargolist:Tstringlist;
           );
      Irgendeins: ();
   end;

[Uwe Raabe]

Was genau spricht denn gegen das overload?

[Andreas L.]

Danke für eure Antworten

Zitat von Uwe Raabe:

Was genau spricht denn gegen das overload?

Weil ich sehr viele Methoden habe, bei denen via Parameter zwei Typen (nämlich String und eine Klasse TtuString) übergeben werden sollen. Ich müsste alle 30 Methoden doppelt deklarieren.

Zitat von QuickAndDirty:

Du kannst einen typlosen paramater verwenden
siehe dazu die Move Prozedur.

Typenlose Parameter kannte ich bereits, hatte aber gehofft das es noch einen "typisierten" Weg gibt. Aber ich denke genau das hier werde ich anwenden.

Zitat von QuickAndDirty:

Dann gäbe es noch den Variant typ als paramaeter. Da kann man quasi alles übergeben.

Variants möchte ich nicht verwenden.

Zitat von QuickAndDirty:

Wenn du die Auswahl an möglichen Typen kennst, dann kannst du eventuell auch mit einem Varianten Record arbeiten.

Delphi-Quellcode:

type
    TFahrzeugList = (Irgendeins, PKW, LKW, Bus, Motorad, Zug);
    TFahrzeug = record
    case Fahrzeug: TFahrzeugList of
      PKW: (MaxSpeed: Integer;
            Cabrio:Boolean;
            DieselFuel:Boolean;
           );
      LKW: (MaxTonage: Single;
            Trailer:Boolean;
           );
      Bus: (Travelers:Integer;
            Toilet:Boolean;
           );
      Motorad: (Speed: integer;
                Sidecar:Boolean;
                HP:integer;
               );
      Zug: (Passengers:integer;
            Cars:integer;
            Cargolist:Tstringlist;
           );
      Irgendeins: ();
   end;

Das wäre in meinem Fall eher weniger geeignet. Trotzdem ein tolles Konstrukt das man auch im Delphi-Code an vielen Stellen findet.

Zitat von LoZe:

wie wäre es mit einem TObject?

Delphi-Quellcode:

function Test(AParam1: TObject): String;
begin
  if AParam1 is TOBJ1 then
  begin
    //
  end;
  if AParam1 is TOBJ2 then
  begin
    //
  end;
end;

Es sollen auch einfache Typen (insbesondere String) übergeben werden können.

[Gausi]

Zitat von Andreas L.:

Weil ich sehr viele Methoden habe, bei denen via Parameter zwei Typen (nämlich String und eine Klasse TtuString) übergeben werden sollen. Ich müsste alle 30 Methoden doppelt deklarieren.

So ins Blaue geraten würde ich mal annehmen, dass beide Varianten in etwa das Gleiche machen, nur dass der String einmal als String, und einmal als Objekt übergeben wird.

Wäre es dann eine Option, jeweils nur die TtuString-Variante zu implementieren, und die andere über ein temporäres tuString-Objekt zu realisieren? Also TuWas(CreateTmpTuString(einString)); ggf. mit optionalem Boolean-Parameter "AutoFree" bei TuWas, damit das temporäre String-Objekt direkt zerstört werden kann?

[Uwe Raabe]

Zitat von Andreas L.:

Weil ich sehr viele Methoden habe, bei denen via Parameter zwei Typen (nämlich String und eine Klasse TtuString) übergeben werden sollen.

Wie werden diese beiden Parametertypen behandelt? Kannst du einfach mal ein Beispiel geben für so eine Methode für String und TtuString (wie ist der Typ überhaupt deklariert)? Insbesondere wäre interessant, wie sich die Implementierung für diese beiden Typen unterscheidet.

[Uwe Raabe]

Um das mal abzukürzen: Nimm einfach TValue aus System.RTTI für den Parameter-Typ.

Delphi-Quellcode:

procedure DoIt(Param: TValue);
begin
  if Param.IsType<string> then
    ShowMessage(Param.AsString)
  else if Param.IsType<TForm> then
    ShowMessage(Param.AsType<TForm>.Caption);
end;

...

procedure TForm831.FormDblClick(Sender: TObject);
begin
  DoIt('string');
  DoIt(Self);
end;

[dummzeuch]

Falls TtuString eine spezielle Art von String ist, könnte man ihn als enhanced Record mit einer implicit-Methode für Umwandlung aus String implementieren. Dann muss man nur den TtuString Parameter haben, weil ein string automatisch in einen TtuString umgewandelt würde.

[Uwe Raabe]

Zitat von dummzeuch:

Falls TtuString eine spezielle Art von String ist,

Wenn ich das richtig lese ist TtuString eine Klasse:

Zitat von Andreas L.:

bei denen via Parameter zwei Typen (nämlich String und eine Klasse TtuString) übergeben werden sollen.

Zitat von dummzeuch:

könnte man ihn als enhanced Record mit einer implicit-Methode für Umwandlung aus String implementieren.

Aber genau diese implizite Umwandlung ist der Grund warum ich TValue vorgeschlagen habe.