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.

Delphi-Quellcode:

procedure Move(const Source; var Dest; Count: Integer);

_
Oder TStream read Methode

Delphi-Quellcode:

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

Delphi-Quellcode:

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:

Zitat von Uwe Raabe (Beitrag 1532548)

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:

Zitat von QuickAndDirty (Beitrag 1532542)

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:

Zitat von QuickAndDirty (Beitrag 1532542)

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

Variants möchte ich nicht verwenden.

Zitat:

Zitat von QuickAndDirty (Beitrag 1532542)

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:

Zitat von LoZe (Beitrag 1532541)

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:

Zitat von Andreas L. (Beitrag 1532556)

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

Delphi-Quellcode:

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:

Zitat von Andreas L. (Beitrag 1532556)

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

Delphi-Quellcode:

String

und

Delphi-Quellcode:

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

Delphi-Quellcode:

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:

Zitat von dummzeuch (Beitrag 1532565)

Falls TtuString eine spezielle Art von String ist,

Wenn ich das richtig lese ist

Delphi-Quellcode:

TtuString

eine Klasse:

Zitat:

Zitat von Andreas L. (Beitrag 1532556)

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

Zitat:

Zitat von dummzeuch (Beitrag 1532565)

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

Delphi-Quellcode:

TValue

vorgeschlagen habe.