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.

[QuickAndDirty]

Krass was für eine Auswahl wir mittlerweile in Delphi haben.

-Typloser Buffer
-Variant
-Varianter Record
-TValue aus RTTI (Das sieht mal ultra komvortabel aus)

Nur um das noch mal zusammen zu fassen.

[freimatz]

:thumb:
Nur dass nicht jemand meint die Liste wäre komplett: es gibt da noch mehr.
Zum Beispiel Klasse mit denen man Daten polymorph abbilden kann. Und am Besten noch interfaces dazu.

[Andreas L.]

Meine Klasse sieht (gekürzt) so aus:

Delphi-Quellcode:

  TtuString = class(TPersistent)
    // ...
  protected
    procedure SetText(Value: String); virtual;
    function UpdateText(AText: String): TtuString; virtual;
    procedure DoChanged; virtual;
  public
    constructor Create(AText: String = ''); reintroduce; overload; virtual;
    constructor Create(AText: TtuString); reintroduce; overload; virtual;
    // ...
    function IsEmpty: Boolean;
    function IsNotEmpty: Boolean;
    function Count: Integer;
    function Length: Integer;
    // ...
    function Insert(AText: String; APosition: Integer = 0): TtuString; overload; virtual;
    // ...
    function Surround(AText: String): TtuString; overload; virtual;
    // ...
    function Replace(ASearchText: String; AReplaceText: String;
      AReplaceFlags: TReplaceFlags = [rfReplaceAll]): TtuString; overload; virtual;
    function Replace(ASearchText: TtuString; AReplaceText: TtuString;
      AReplaceFlags: TReplaceFlags = [rfReplaceAll]): TtuString; overload; virtual;
    // ...
  published
    property OnChanged: TNotifyEvent
      read FOnChanged write FOnChanged;
    property Text: String
      read FText write SetText;
  end;

Benutzt werden soll die Klasse wie folgt:

Delphi-Quellcode:

var
  Str: TtuString;
begin
  Str := TtuString.Create('Hallo, Welt!');
  try
    // Folgender Aufruf ersetzt zuerst ', Welt!' mit einem Leerstring, 
    // fügt dann ein Ausrufezeichen an und stellt dem neuen String 
    // drei Unterstriche voran bzw. hängt diese auch an...
    Str.Replace(', Welt!', '').Insert('!').Surround('___');

    // Folgendes gibt aus: '___Hallo!___'
    ShowMessage(Str.Text);
  finally
    FreeAndNil(Str);
  end;
end;

Jetzt möchte ich die Klasse so gestalten, dass auch bereits existierende TtuString-Instanzen an die vielen, vielen String-Manipulations-Methoden (wie bei Replace zu sehen ist...) übergeben werden können.

Ich werde dafür auf die Variante mit TValue von Uwe Raabe zurückgreifen. Ich finde das diese Lösung am ehesten passt. Was meint ihr? TtuString als Record zu definieren und mit diversen "class operator"-Routinen auszustatten, hätte aber auch was...

By the way: Für das verschachtelte aufrufen (.Replace().Insert()...) gibt es einen speziellen Namen. Wie genau heißt dieses Schema oder Prinzip?

[mytbo]

Zitat:

Zitat von Andreas L. (Beitrag 1532908)

By the way: Für das verschachtelte aufrufen (.Replace().Insert()...) gibt es einen speziellen Namen. Wie genau heißt dieses Schema oder Prinzip?

Fluent Interface

Bis bald...
Thomas