Zwei Funktionen mit dem selben Namen?

[Benmik]

Was noch nicht erwähnt wurde: In deinem konkreten Beispiel könntest du die drei angegebenen Funktionen mit

Delphi-Quellcode:

overload

realisieren, indem du die Parameterreihenfolge änderst:

Delphi-Quellcode:

Function bla (X:integer; y:boolean; x: boolean): Boolean; overload;
Function bla (X:integer; x: boolean): Boolean; overload;
Function bla (y:boolean: X:integer): Boolean; overload;

Die kann der Compiler alle auseinanderhalten, da es bei der ersten Funktion drei Parameter gibt, und bei den beiden anderen die Parameter nicht gleich sind; denn ob der Compiler als erstes Argument einen Integer oder einen Boolean erwartet, das ist für ihn etwas völlig Verschiedenes.

Wenn es dir sehr am Herzen liegt, kannst du auch den folgenden Trick anwenden (das gibt hier natürlich jetzt einen Aufschrei, aber funktionieren tut es selbstredend):

Delphi-Quellcode:

Function bla (X:integer; x: boolean; Dummy:TObject): Boolean; overload;

Das rufst du mit

Delphi-Quellcode:

bla(42,True,nil)

auf. Durch Verwürfeln der Reihenfolge kannst du noch einige Funktionen

Delphi-Quellcode:

bla

realisieren.

[NoGAD]

Hallo Benmik,

danke für die Erklärung und Beispiele.

LG 😊👋🏻

[himitsu]

Stattdessen kann man alles auch in ein Objekt/MethodenRecord verpacken
auch einen Parameter-Record/Objekt erstellen und hat dann bloß einen einzigen Parameter.
Dank der neuen Custom Managed Records wird es damit auch immer einfacher.

Delphi-Quellcode:

type
  TLIParams = record  // oder als TObject (dann aber das Create/Free nicht vergessen)
    Worte: Integer;
    Absatz: Integer;
    UsePre: Boolean;
    Variante: TLoremIpsumVariant;
    Punktierung: Boolean;
    Kommata: Boolean;

    class operator Initialize(out Dest: TLIParam);  // wird automatisch bei neuen Variablen aufgerufen
    //oder ein manuelles "procedure Clear;"
  end;
 
function MakeLoremIpsum(Params: TLIParams): String;

Im Clear/Initialize alle "Parameter" auf 0/False setzen.

Delphi-Quellcode:

type
  TLoremIpsum = record  // oder als TObject (dann aber das Create/Free nicht vergessen)
    Worte: Integer;
    Absatz: Integer;
    UsePre: Boolean;
    Variante: TLoremIpsumVariant;
    Punktierung: Boolean;
    Kommata: Boolean;

    class operator Initialize(out Dest: TLIParam);  // wird automatisch bei neuen Variablen aufgerufen
    //oder ein manuelles "procedure Clear;"

    function Make: String;
  end;

Delphi-Quellcode:

{ function CreateLoremIpsum(aWorte: Integer; aUsePre: Boolean): String; }
var LI: TLoremIpsum;  
// LI.Clear; oder automatisch durch Initialize erstmal alles auf 0 setzen lassen.
// Früher auch gern mit einem FillChar(LI, SizeOf(LI), 0);
LI.Worte := 123;
LI.UsePre := True;
ShowMessage(LI.Make);

Delphi-Quellcode:

type
  TLoremIpsum = record  // oder als TObject (dann aber das Create/Free nicht vergessen)
    Worte: Integer;
    Absatz: Integer;
    UsePre: Boolean;
    Variante: TLoremIpsumVariant;
    Punktierung: Boolean;
    Kommata: Boolean;

    DerText: String;

    class operator Initialize(out Dest: TLIParam);  // wird automatisch bei neuen Variablen aufgerufen
    //oder ein manuelles "procedure Clear;"

    procedure Make;  // Result siehe DerText
  end;

[mmw]

Hallo,

Zu #16

[OT]

https://www.bielefeldmillion.de/biel...verschwoerung/

[/OT]

Gruß

[NoGAD]

Hallo an alle,

ich hatte zwischenzeitlich (kein Crosspost) meine (neue) Unit in einem älteren Beitrag gepostet: https://www.delphipraxis.net/209772-...h-am-ende.html

Wo wäre es günstiger, weiterzumachen?

LG :-)

[Rolf Frei]

Zitat:

Zitat von Benmik (Beitrag 1507744)

Was noch nicht erwähnt wurde: In deinem konkreten Beispiel könntest du die drei angegebenen Funktionen mit

Delphi-Quellcode:

overload

realisieren, indem du die Parameterreihenfolge änderst:

Delphi-Quellcode:

Function bla (X:integer; y:boolean; x: boolean): Boolean; overload;
Function bla (X:integer; x: boolean): Boolean; overload;
Function bla (y:boolean: X:integer): Boolean; overload;

Die kann der Compiler alle auseinanderhalten, da es bei der ersten Funktion drei Parameter gibt, und bei den beiden anderen die Parameter nicht gleich sind; denn ob der Compiler als erstes Argument einen Integer oder einen Boolean erwartet, das ist für ihn etwas völlig Verschiedenes.

Wenn es dir sehr am Herzen liegt, kannst du auch den folgenden Trick anwenden (das gibt hier natürlich jetzt einen Aufschrei, aber funktionieren tut es selbstredend):

Delphi-Quellcode:

Function bla (X:integer; x: boolean; Dummy:TObject): Boolean; overload;

Das rufst du mit

Delphi-Quellcode:

bla(42,True,nil)

auf. Durch Verwürfeln der Reihenfolge kannst du noch einige Funktionen

Delphi-Quellcode:

bla

realisieren.

Sein Originalcode aus dem ersten Post lässt sich problemlos kompilieren, wenn da overload's angehängt werden. Das Ganze macht aber da keinen Sinn, weil er nur die Letzte Funcktion benötigt und die vorherigen damit alle auch abgedeckt sind. Ich vermute mal stark , dass der Delphi Compiler intelligent genug ist, um das selber zu merken und dabei die überflüssigen Functions einfach ignnoriert/eliminiert.

[himitsu]

Zitat:

Zitat von Rolf Frei (Beitrag 1507839)

Sein Originalcode aus dem ersten Post lässt sich problemlos kompilieren, wenn da overload's angehängt werden.

jain.

Kompilieren ja, aber nur so lange du nicht versuchst diese Funktionen aufzurufen, da nur die letzte Variante eindeutig ist, wenn man alle Parameter übergibt.

Delphi-Quellcode:

CreateLoremIpsum;

Code:

[dcc32 Fehler] Unit21.pas(54): E2251 Doppeldeutiger überladener Aufruf von 'CreateLoremIpsum'
  Unit21.pas(31): Verwandte Methode: function CreateLoremIpsum(Integer): string;
  Unit21.pas(46): Verwandte Methode: function CreateLoremIpsum(Integer; Integer; Boolean; TLoremIpsumVariant): string;
  Unit21.pas(41): Verwandte Methode: function CreateLoremIpsum(Integer; Integer; Boolean): string;
  Unit21.pas(36): Verwandte Methode: function CreateLoremIpsum(Integer; Integer): string;
[dcc32 Fataler Fehler] Project21.dpr(5): F2063 Verwendete Unit 'Unit21.pas' kann nicht compiliert werden

Keine Ahnung, warum das überhaupt erst kompiliert und der Compiler nicht sofort abraucht, wenn er auf eine doppeldeutige Deklaration im selben Namespace trifft.