Überladen von Methoden kollidiert mit Funktionszeiger-Parameter (Anonyme Methode)

[s.h.a.r.k]

Ich habe gerade ein lustiges Problem bzgl. dem Überladen von Methoden und einem Parameter mit einem Funktionszeiger (reference to function...). Hier kann man die Definition und das Problem sehen.

Delphi-Quellcode:

TApArray<T> = record
private
  TToStringFunc = reference to function (Value: T): String;
public
  function ToString(const ToStrFunc: TToStringFunc; const Separator: String; const Prefix, Suffix: String): String; overload;
  function ToString(const ToStrFunc: TToStringFunc; const Separator: String; const UseAffix: Boolean): String; overload;
  function ToString(const ToStrFunc: TToStringFunc; const Prefix, Suffix: String): String; overload;
  function ToString(const ToStrFunc: TToStringFunc; const UseAffix: Boolean): String; overload;
  function ToString(const ToStrFunc: TToStringFunc; const Separator: String): String; overload;
  function ToString(const ToStrFunc: TToStringFunc): String; overload;
  function ToString(const Separator: String; const Prefix, Suffix: String): String; overload;
  function ToString(const Separator: String; const UseAffix: Boolean): String; overload;
  function ToString(const Prefix, Suffix: String): String; overload;
  function ToString(const UseAffix: Boolean): String; overload;
  function ToString(const Separator: String): String; overload;
  function ToString(): String; overload;
end;


var
  A : TApArray<Integer>;
  F : TApArray<Integer>.TToStringFunc;
begin
  F :=  function (Value: Integer): String
       begin
         Result := IntToStr(Value);
       end;
  A.ToString(); // klappt
  A.ToString(F); // klappt
  A.ToString(IntToStr); // -> [DCC Fehler] Testing.pas(1004): E2035 Nicht genügend wirkliche Parameter
  A.ToString(IntToStr, '|', False); // klappt
  A.ToString(IntToStr, ';', '(', ')'); // klappt

Ich verstehe hier nicht ganz, warum Delphi beim dritten Aufruf ein Problem hat, denn eigentlich gibt es ja eine entsprechende Methode, die einen einzigen Parameter vom Typ TToStringFunc übernimmt. Warum sollten hier noch weitere Parameter fehlen? Warum funktioniert denn der Aufruf mit dem Parameter F?

[himitsu]

Versuch mal

Delphi-Quellcode:

A.ToString(@IntToStr);

,
denn eigentlich willst du ja einen Funktionszeiger übergeben und nicht das Result einer Funktion.

Delphi will diesen Aufuf wohl an

Delphi-Quellcode:

function ToString(const Separator: String): String; overload;

übergeben und da fehlen beim IntToStr wirklich ein paar Parameter. :angle2:

PS:

Zitat:

Delphi-Quellcode:

function ToString(const ToStrFunc: TToStringFunc: String; overload;

irgendwas stimmt dort nicht :stupid:

[s.h.a.r.k]

Dein Vorschlag mit dem @IntToStr liefert mir die folgende Fehlermeldung -- hatte das auch schon ausprobiert:

Code:

[DCC Fehler] Testing.pas(1012): E2250 Es gibt keine überladene Version von 'ToString', die man mit diesen Argumenten aufrufen kann

Gibts auch andere Vorschläge? Würde man einen Default-Wert für anonyme Methoden definieren können, wäre das absolut kein Problem. Aber so kann ich nicht mal durch Änderung der Parameterreihenfolge dem Problem beikommen...

PS: Hab den Fehler gefixt -- muss beim Einfügen passiert sein :stupid:

[himitsu]

Im

Delphi-Quellcode:

reference to

steckt ein Interface ... da könnte man es mal mit

Delphi-Quellcode:

= nil

als Standardparameter versuchen.

Du könntest es auch mal ohne Const bei der a. Methode probieren
und/oder die Stringvariante vor der Methoden-Variante deklarieren.

Ich hätte aber erwartet, daß @ funktioniert. :shock:

Denn was sollte man erwarten, wenn die Funktion eine a. Methode als Result zurückgiebt?

Delphi-Quellcode:

function Blub: TToStringFunc;
...

A.ToString(@Blub);  // Zeiger auf die Funktion
A.ToString(Blub);   // der Zeiger aus dem Result

Eine Automatik, welche ein implizites @, bei solchen Zuweisungen setzt, ist ja vollkommen OK,
aber das @, worüber man etwas eindeutig zuweisen kann, sollte dennoch funktionieren.

[s.h.a.r.k]

Ich kann dir schon gar nicht mehr sagen, was ich schon alles probiert habe und was nicht. U.a. das

Delphi-Quellcode:

= nil

als Default-Wert... Der Compiler meint, dass ich das nicht darf.

Das mit dem @ hatte ich auch schon probiert, ging nicht... Ich sag ja, ich check nicht, warum das nicht funktioniert. Und anonyme Methoden sind halt schon was geiles, daher will ich das Feature (also das reference to) eigentlich auch drin lassen.

Das mit dem const kann ich allerdings wahrlich noch testen, wobei ich dann den Unterschied nicht verstehen würde :roll: Aber man kann ja nie wissen, was der Compiler intern alles für Sachen macht.

[Namenloser]

Das Problem ist, dass du hast:

Delphi-Quellcode:

function ToString(const ToStrFunc: TToStringFunc): String; overload;
{…}
function ToString(const Separator: String): String; overload;

Der Rückgabewert von IntToStr ist String; deshalb nimmt der Compiler an, dass du die 2. Variante meinst, und bemerkt dann, dass ein Parameter fehlt.

[negaH]

Delphi-Quellcode:

function ToString(const  ToStrFunc: TToStringFunc; const Separator: String = ''): String; overload;
// function ToString(const ToStrFunc: TToStringFunc): String; overload;

letzte Methode komplett raus und erste Methode ein default Wert für letzten Parameter.

[s.h.a.r.k]

@negaH: Ich hätte aber gerne den ToStrFunc-Parameter optional :stupid: Und genau das bekomme ich bisher leider nicht so wirklich gebacken. Mal schauen, vielleicht fällt mir ja noch was ein...

[negaH]

@s.h.a.r.k

Da das ein Compilerfehler ist kannst du den Compiler ändern oder musst eine Lösung nehmen die das Problem umgeht, oder du träumst weiter sorry wenn ich das so sagen muß.

Versuche mal meinen Vorschlag, ich habe ja nicht explizit gesagt das er auch funktionieren wird. Am Ende solltest du alle "überladenen Methoden und Funktionen" folgendermaßen betrachten. Aus Sicht des Benutzers deiner Schnittstellen die du jetzt deklarieren möchtest sollten alle überladenen Methoden und Funktion gleichen Names wie eine Funktionalität betrachtet werden, so als ob du nur einmal eine Funktion deklarieren würdest bei der du alle möglichen Parameterkombinationen in der Parameterliste definieren kannst. Denn genau das ist das Prinzip des Überladens.

Ich selber hatte nämlich exakt die gleichen Probleme wie du schon mit der D5 Version und meinen large Integer IInteger Objekten. Das von Borland benutzte Prinzip das man die Deklaration einer überladenen Funktionalität mit Hilfe meherer Funktionsdeklarationen erledigen muß führt zu mehreren solchen Problemen bei dem es dem Compiler schlicht unmöglich ist die Funktionen wieder an Hand ihrer Parameterliste wieder auflösen zu können. Verschärft wird das zusätzlich durch die Möglichkeit der Defaultwerte für die Parameter. Noch weiter verschärft sich das wenn man mit Objekten und überladenen Methoden in diesem Rahmen arbeiten möchte.

Überladene Funktionen können ein Segen wie auch Fluch sein, besonders wenn der Compiler Macken hat.

Gruß Hagen

[Stevie]

Du kannst F auch direkt IntToStr zuweisen und das dann an die ToString Methode übergeben.
Wie schon erwähnt, kann der Compiler nunmal nicht wissen, ob du das Ergebnis von IntToStr oder die Funktion selber als reference übergeben möchtest, bzw er entscheidet sich für das Ergebnis des Aufrufes. Das ganze könnte gelöst werden, wenn man bei Aufruf von Routinen die Klammern zwingend erforderlich machen würde, dann könnte man daran erkennen, ob es ein Aufruf sein soll oder nicht. Geht aber nicht wegen Abwärtskompatibilität.

P.S.: Oder naja, man könnte diese Funktionalität zumindest an solchen Stellen einbauen. Somit würde der Compiler zuerst versuchen, die Routine als reference zu übergeben, falls eine überladene Version der Methode das unterstützt.

P.P.S.: Mach dir ne weitere Überladung mit

Delphi-Quellcode:

TToStringFunc2 = function (Value: T): String;

, die akzeptiert dann @IntToStr.