Zwei Funktionen mit dem selben Namen?

[NoGAD]

Hallo,

wie macht es Borland eigentlich, dass es zwei verschiedene Funktionen mit dem gleichen Namen, aber unterscheidlichen Parametern geben darf?


Beispiel:

1. Format const Format: string; const Args: array of const
2. Format const Format: string; const Args: array of const; const AFormatSettings: TFormatSettings

Ich würde das auch gerne machen, mit einem LoremIpsum - Generator:


function CreateLoremIpsum(aWorte: Integer = 2): String;
function CreateLoremIpsum(aWorte: Integer = 2; aAbsatz: Integer = default(Integer)): String;
function CreateLoremIpsum(aWorte: Integer = 2; aAbsatz: Integer = default(Integer); aUsePre: Boolean = True): String;
function CreateLoremIpsum(aWorte: Integer = 2; aAbsatz: Integer = default(Integer); aUsePre: Boolean = True; aVariante: TLoremIpsumVariant = Standard): String;

LG :-)

[Rolf Frei]

In dem die Funktionen mit "overload" markiert sind.

Delphi-Quellcode:

function CreateLoremIpsum(aWorte: Integer = 2): String; overload;
function CreateLoremIpsum(aWorte: Integer = 2; aAbsatz: Integer = default(Integer)): String; overload;
function CreateLoremIpsum(aWorte: Integer = 2; aAbsatz: Integer = default(Integer); aUsePre: Boolean = True): String; overload;
function CreateLoremIpsum(aWorte: Integer = 2; aAbsatz: Integer = default(Integer); aUsePre: Boolean = True; aVariante: TLoremIpsumVariant = Standard): String; overload;

Da du hier aber alles mit Default Parametern arbeitest, brauchst du garkeine überladnen Funktionen. Die letzte Funktion reicht da.

[PaPaNi]

Keyword overload hilft nicht?

Beispiel:

Delphi-Quellcode:

function Foo(_Param1: Integer=2; _Param2 : Integer=3) : string; overload;
function Foo(_Param1: Integer=2; _Param2 : Integer=3; _Param3: Boolean = True) : string; overload;
function Foo(_Param1: Integer=2; _Param2 : Integer=3; _Param3: Boolean = True; _Param4: Boolean = True) : string; overload;

[bernau]

Die Funktionen mit einem Overload kennzeichnen

Delphi-Quellcode:

function CreateLoremIpsum(aWorte: Integer = 2): String;overload;
function CreateLoremIpsum(aWorte: Integer = 2; aAbsatz: Integer = default(Integer)): String;overload;
function CreateLoremIpsum(aWorte: Integer = 2; aAbsatz: Integer = default(Integer); aUsePre: Boolean = True): String;overload;
function CreateLoremIpsum(aWorte: Integer = 2; aAbsatz: Integer = default(Integer); aUsePre: Boolean = True; aVariante: TLoremIpsumVariant = Standard): String;overload;

[Edit]
Hahaha. Drei mit dem gleichen Gedanken

[himitsu]

overload


Aber so geht das garnicht, da du optionale Parameter dabei nicht betrachten darfst, weil es kann sein, dass sie nicht angegeben werden.
Es müssen sich die Typen der Parameter unterscheiden. (Parameter-Name und Result-Typ und Default-Values sind irrelevant)

Also alle Default-Parameter bei dir weggelassen und schon sind alle Varianten identisch und lassen sich somit nicht überladen.

Delphi-Quellcode:

function CreateLoremIpsum(aWorte: Integer = 2): String; overload;
function CreateLoremIpsum(aWorte: Integer; aAbsatz: Integer): String; overload;
function CreateLoremIpsum(aWorte: Integer; aAbsatz: Integer; aUsePre: Boolean): String; overload;
function CreateLoremIpsum(aWorte: Integer; aAbsatz: Integer; aUsePre: Boolean; aVariante: TLoremIpsumVariant): String; overload;

Aber gerade an diesem Beispiel ist diese ganze Angelegenheit eh total sinnlos, da alle Fälle durch die letzte/längste Funktion behandelt werden, wenn dort alles mit Default-Values versehen ist.

[bernau]

Himitsu hat es mit den Defaultparametern natürlich auf den Punkt gebracht. :thumb:

[NoGAD]

Hallo nochmal,


danke euch allen. overload war mir natürlich bekannt. Dennoch mach tes Borland anders:

https://docwiki.embarcadero.com/Libraries/Sydney/de/System.SysUtils.Format

Ohne overload.

Daher meine Frage.

LG

[himitsu]

Wer behauptet denn, dass es dort nicht mit Overload deklariert ist?

Man schaue nur mal in die System.SysUtils.pas :roll:

[Neutral General]

Zitat:

Zitat von NoGAD (Beitrag 1507719)

Dennoch mach tes Borland anders:

https://docwiki.embarcadero.com/Libraries/Sydney/de/System.SysUtils.Format

Ohne overload.

Das ist nur die Dokumentation. Dort wurde nicht explizit overload dazugeschrieben.
Wenn du in den Source der SysUtils schaust sieht das so aus:

Delphi-Quellcode:

function Format(const Format: string; const Args: array of const): string; overload;
function Format(const Format: string; const Args: array of const; const AFormatSettings: TFormatSettings): string; overload;

[PaPaNi]

Die Funktion CompareStr hat auch 2 Versionen:

Delphi-Quellcode:

function CompareStr(const S1, S2: string): Integer; overload;
function CompareStr(const S1, S2: string; LocaleOptions: TLocaleOptions): Integer; overload;

aber auf Emba-Seite sind sie wieder ohne overload beschrieben:

https://docwiki.embarcadero.com/Libr...ils.CompareStr

Also, das ist in der Dokumentation gewollt so.

[EvoOlli]

Im Quellcode macht es auch Borland mit overload;

[Rolf Frei]

Die Doku sagt nichts darüber aus, wie es denn effektiv in den Sourcen steht. Schau dir dazu die Sourcen an, die sind massgebend. Das folgende stammt aus System.SysUtils.pas:

Delphi-Quellcode:

unction Format(const Format: string;
  const Args: array of const): string; overload;
function Format(const Format: string; const Args: array of const;
  const AFormatSettings: TFormatSettings): string; overload;

[NoGAD]

Ich bedanke mich ganz herzlich bei euch. :-)



Zu den Funktionen habe ich noch eine weitere Frage:

Wie ist das technisch eigentlich von Borland geregelt, dass erkannt wird, welche Funktion aufgerufen wird?

Als Beispiel habe ich jetzt noch:

Delphi-Quellcode:

var
  Absatz: Integer;
  UsePre: Boolean;
  Variante: TLoremIpsumVariant;
{..}
function CreateLoremIpsum(aWorte: Integer; aVariante: TLoremIpsumVariant): String;
begin
  Result := CreateLoremIpsum(aWorte, Absatz, UsePre, aVariante);
end;

gemacht und der Compiler kommt dennoch nicht durcheinander mit einer anderen 2-Parameter-Funktion.

LG :-)

[Neutral General]

Der Compiler schaut ja nicht nur auf die Anzahl der Parameter sondern auch auf den Typ.

Wenn du 2 gleichnamige Funktionen hast

Delphi-Quellcode:

procedure Test(a: String; b: String);
procedure Test(a: String; b: Integer);

und dann so einen Aufruf:

Delphi-Quellcode:

Test('Hallo', 23);

Dann kann der Compiler ja anhand der Parameter ableiten welche Funktion gemeint ist.

[himitsu]

Anhand der Typen, welche beim Aufruf übergeben werden.

Delphi-Quellcode:

procedure abc(i: Byte); overload;
procedure abc(i: string); overload;

Delphi-Quellcode:

procedure abc(i: Byte); overload;
procedure abc(i: Integer); overload;

also

Delphi-Quellcode:

var x: Byte; abc(x);

geht immer,
aber mit

Delphi-Quellcode:

abc(1);

gibt es beim Zweiten ein Problem, denn was ist 1 für ein Typ?

Auch muß man z.B. bei Überladungen von Pointer und TObjekt aufpassen.
Gibt man da eine Variable rein, dann geht es immer, aber bei

Delphi-Quellcode:

abc(nil);

ist es wieder nicht eindeutig.

[Sinspin]

[OT]

Zitat:

Zitat von NoGAD (Beitrag 1507726)

... Borland...

:gruebel:
Würdest du jetzt in Bielefeld leben und nicht in Weimar, würde ich sagen, "Ok, so leicht kommen Informationen halt nicht nach Bielefeld. Da kann man verstehen das es noch nicht durchgedrungen ist dass die jetzt Embarcadero heißen". Aber Du lebst ja in Weimar. Da gibt es zwar eine Gärtnerei Bielefeld, aber ansonsten sind dort alle voll auf dem Laufenden.
[/OT]

[himitsu]

Nja, eigentlich heißt die Firma ja bereits Idera, aber Dubai ist vielleicht noch zu weit weg. :stupid:


Alles heißt Maggi, auch wenn es nicht von Maggi ist.

[NoGAD]

:)


Danke für die Erklärung.

Somit wäre es nicht möglich, zwei Funktionen von einer "langen" abzuleiten / zu erstellen, die im Prinzip vom Typ her gleich sind, aber andere Parameter besitzen:

1. Function bla (X:integer; y:boolean; x: boolean): Boolean; overload;
2.1 Function bla (X:integer; x: boolean): Boolean; overload;
2.2 Function bla (X:integer; y:boolean): Boolean; overload;

2.2. waäre dann nicht möglich, weil der compiler nicht weiß, was was ist, richtig?


OT: Rad Studio ist für mich immer noch Delphi und Borland ist die FA, die ich damit in Verbindung bringe ;-)

LG Mathias.

[Neutral General]

Zitat:

Zitat von NoGAD (Beitrag 1507739)

2.2. waäre dann nicht möglich, weil der compiler nicht weiß, was was ist, richtig?

richtig.

Zitat:

Zitat von himitsu (Beitrag 1507734)

Nja, eigentlich heißt die Firma ja bereits Idera, aber Dubai ist vielleicht noch zu weit weg. :stupid:

Nur der Vollständigkeit halber: Codegear
Jetzt haben wir glaube ich alle durch :mrgreen:

[NoGAD]

Zitat:

Zitat von Neutral General (Beitrag 1507740)

Zitat:

Zitat von NoGAD (Beitrag 1507739)

2.2. waäre dann nicht möglich, weil der compiler nicht weiß, was was ist, richtig?

richtig.

Zitat:

Zitat von himitsu (Beitrag 1507734)

Nja, eigentlich heißt die Firma ja bereits Idera, aber Dubai ist vielleicht noch zu weit weg. :stupid:

Nur der Vollständigkeit halber: Codegear
Jetzt haben wir glaube ich alle durch :mrgreen:

Danke :-)


Nebenbei, Idera scheint doch korrekt zu sein.

https://www.embarcadero.com/de/company/about-us

[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.