Funktion Überladen --> Doppeldeutiger überladener Aufruf

[Ares]

Hallo!

Ich will eine Funktion GetString(ID: Integer) schreiben, die mir aus einer Liste einen bestimmten String liefert. Optional soll es zwei weitere Möglichkeiten geben:
1. String-Formatierung mit der Format() Funktion
2. String-Formatierung mit bestimmten, selbstdefinierten Optionen

Für diese Möglichkeiten habe ich die Funktion wie folgt überladen:

Delphi-Quellcode:

type
  TStringOption  = (soQuoted, soBlank, soColon);
  TStringOptions = set of TStringOption;

function GetString(ID: Integer; StringOptions: TStringOptions=[]): String; overload;
function GetString(ID: Integer; Args: array of TVarRec): String; overload;
function GetString(ID: Integer; StringOptions: TStringOptions;
  Args: array of TVarRec): String; overload;

implementation

function GetString(ID: Integer; StringOptions: TStringOptions=[]): String;
begin
  result := GetString(ID, StringOptions, []);
end;

function GetString(ID: Integer; Args: array of TVarRec): String;
var dummy: TStringOptions;
begin
  dummy := [];
  result := GetString(ID, dummy, Args);
end;

function GetString(ID: Integer; StringOptions: TStringOptions;
  Args: array of TVarRec): String;
begin
  result := IrgendwieStringHolen(ID);  
  
  Format(result, Args); 

  if (soColon in StringOptions)  then result := result+':';
  if (soBlank in StringOptions)  then result := result+' ';
  if (soQuoted in StringOptions) then result := '"'+result+'"';
end;

Mit dieser Definition sollten eigentlich folgende Aufrufe der Funktion möglich sein:

Delphi-Quellcode:

GetString(123);              // Unformatierten String erhalten
GetString(123, [soQuoted]);  // String mit ".." erhalten
GetString(123, ['hallo']);   // String erhalten bei dem ein %s durch "hallo" ersetzt ist

// String mit ".." erhalten und bei dem ein %s durch "hallo" ersetzt ist
GetString(123, [soQuoted], ['hallo']);

Auf den Aufrufen von 2 und 3 erhalte ich jedoch die Meldung Doppeldeutiger überladener Aufruf von 'GetString'. Eigentlich sollte Delphi doch durch den Typ der Parameter bestimmen können, welche Funktion genutzt werden soll. Einmal ist der zweite Parameter eindeutig ein Array und einmal eindeutig eine Menge. Wo ist also das Problem?

Ich habe schon versucht die Defaultbelegung TStringOptions=[] wegzulassen und stattdessen eine weitere überladene Version der Funktion zu nutzen. Das Ergebnis ist das Gleiche.

Die Funktion GetString zusammen mit dem TVarRec nutze ich schon an sehr vielen Stellen in meinen Programmen. Ich wollte nun nur zusätlich die eigenen Optionen einfügen, ohne dass die vorhandenen Aufrufe von GetString geändert werden müssen.

Was mache ich also falsch und wie lässt sich das Problem umgehen?

Natürlich könnte ich nur eine Version der Funktion benutzen bei der alle Parameter angegeben werden müssen. Aber zum einen sollte das Überladen von Funktionen doch kein Problem sein und zum anderen müsste ich dann die vielen vorhandenen Aufrufe von GetString ändern. Das will ich möglichst vermeiden.

Besten Dank
Ares



Dazu soll es noch die Möglichkeit geben der Funktion Argument für die String-Formatierung und

[messie]

Zitat:

Zitat von OH

If you use default parameter values in an overloaded routine, avoid ambiguous parameter signatures. Consider, for example, the following.

Delphi-Quellcode:

procedure Confused(I: Integer); overload;

 ...
procedure Confused(I: Integer; J: Integer = 0); overload;
 ...
Confused(X);    //  Which procedure is called?

In fact, neither procedure is called. This code generates a compilation error.

Die Parametersätze in den unterschiedlichen Deklarationen dürfen nicht übereinstimmen, was in Deinem Fall aber mehrfach so ist. Das ist mit der Doppeldeutigkeit gemeint.

Grüße, Messie

[himitsu]

@messie:
tun sie doch auch nicht.

Delphi-Quellcode:

// das
ID: Integer; StringOptions: TStringOptions=[];
// enspricht dem und soeinen Parametersatz gibt es noch nicht
ID: Integer;

und die beiden anderen Parametersätze sind

Delphi-Quellcode:

ID: Integer; Args: array of TVarRec
ID: Integer; StringOptions: TStringOptions; Args: array of TVarRec

also meiner Meinung nach sollte es eigentlich gehn :gruebel:

Code:

Integer; [color=#a0a0a0]TStringOptions[/color]
Integer; array_of_TVarRec
Integer; TStringOptions; array_of_TVarRec

[messie]

Aber das erste Argument ist immer ein integer. Das entspricht genau dem, was die OH als abschreckendes Beispiel genannt hat. Woher soll die Funktion wissen, wieviel Speicherplätze mit welcher Speicherstruktur sie beim Aufruf für die Parameter reservieren soll?

Grüße, Messie

[RavenIV]

Zitat:

Zitat von himitsu

Delphi-Quellcode:

function GetString(ID: Integer; StringOptions: TStringOptions=[]): String; overload;
function GetString(ID: Integer; Args: array of TVarRec): String; overload;
function GetString(ID: Integer; StringOptions: TStringOptions;
  Args: array of TVarRec): String; overload;

Das funktioniert so auch nicht.
Wenn Du bei der dritten Schreibweise den zweiten und dritten Parameter vertauschst, dann könnte es klappen.

[himitsu]

Nein, die OH schrieb von

Code:

procedure Confused([color=red]Integer[/color]);
procedure Confused([color=red]Integer[/color]; [color=silver]Integer=0[/color]);

fällt dir was auf?

die zweite Prozedur endspricht genau der Ersten, wenn man den optionalen Parameter wegläßt.

[Dax]

Delphi-Quellcode:

function GetString(ID: Integer; StringOptions: TStringOptions=[]): String; overload;
function GetString(ID: Integer; Args: array of TVarRec): String; overload;
function GetString(ID: Integer; StringOptions: TStringOptions;
  Args: array of TVarRec): String; overload;

Was stellt [] bei GetString(0, []) nun dar? Ein leeres Set oder ein leeres Array?

[DeddyH]

IMHO sollte es so ohne Probleme gehen:

Delphi-Quellcode:

function GetString(ID: Integer; StringOptions: TStringOptions=[]): String; overload;
function GetString(Args: array of TVarRec; ID: Integer): String; overload; //Argumente getauscht
function GetString(ID: Integer; StringOptions: TStringOptions;
  Args: array of TVarRec): String; overload;

Falls nicht, möge man mich korrigieren.

[messie]

So ähnlich hatte ich das auch schon probiert - also jedesmal ein neuer einleitender Parameter. Gescheitert ist der Compiler daran, daß er laut #1 eine jeweils andere Variante "von sich selbst" aufrufen sollte. Da scheint sogar die Reihenfolge der Deklarationen Einfluss zu haben.
Ein interessantes Thema...

Grüße, Messie

[Dax]

Delphi-Quellcode:

function GetString(ID: Integer; StringOptions: TStringOptions=[]): String; overload;
function GetString(ID: Integer; Args: array of TVarRec; StringOptions: TStringOptions = []): String; overload;

Geht das denn so?