Existe-t-il un moyen de surcharger une fonction basée sur un type de résultat différent dans Delphi?

Question

Function overloading by return type?

a une réponse très détaillée sur le rationnel sur la surcharge de fonction par type de retour, et de ce que je peux voir Delphi ne permet pas, mais qu'il y a des solutions de contournement de surcharger une fonction basée sur différents types de retour dans Delphi ?

Answer 1

Les opérateurs de conversion implicites et explicites pour les enregistrements permettent la surcharge par type de retour: à savoir, le type étant converti en:

type 
    TFoo = record 
    class operator Implicit(const AFoo: TFoo): Integer; 
    class operator Implicit(const AFoo: TFoo): string; 
    end; 

En fonction du contexte, en utilisant une valeur de type TFoo appellera la conversion implicite appropriée. Si vous essayez d'utiliser une valeur de type TFoo comme argument à une routine surchargée qui peut prendre soit entier ou une chaîne dans cette position, une erreur de surcharge se produira:

test.pas(33) Error: E2251 Ambiguous overloaded call to 'Q' 
+ Test.pas(19) Related method: procedure Q(Integer); 
+ Test.pas(24) Related method: procedure Q(const string); 

Answer 2

Vous pouvez prendre le "résultat" comme paramètre.

procedure Blah(InVar : word; out OutVar : Byte); overload; 
procedure Blah(InVar : word; out OutVar : String); overload; 

Answer 3

Je pris l'idée ci-dessus et mis en œuvre dans un Tokenreader utilisé pour importer des données. Chaque jeton est une chaîne, qui est ensuite convertie au type approprié. Le code requis pour la conversion en nombre entier et chaîne est en bas de la publication.

Pour lire et convertir un jeton que le code suivant est nécessaire:

Myvalue := DataImporter.ImportToken; 

En fonction du type de maValeur, est déclenché la bonne conversion implicite.

---

Le code:

TTokenValue = record 
public 
    FValue:string; 
    constructor Create(const AValue:string); 
    class operator Implicit(const AFoo:TTokenValue): integer; 
    class operator Implicit(const AFoo:TTokenValue): string; 
end; 

mise en œuvre

function TDataImporter.ImportToken: TTokenValue; 
begin 
    result := TTokenValue.Create(GetCurrentToken()); 
end; 

constructor TTokenValue.Create(const AValue: string); 
begin 
    FValue := AValue; 
end; 

class operator TTokenValue.Implicit(const AFoo: TTokenValue): integer; 
begin 
    result := strtointdef(AFoo.FValue, 0); 
end; 

class operator TTokenValue.Implicit(const AFoo: TTokenValue): string; 
begin 
    result:=AFoo.FValue; 
end;