Funktion Überladen --> Doppeldeutiger überladener Aufruf

[Ares]

Hallo!

Vielen Dank für eure zahlreichen Beiträge. Ich hatte am Wochenende leider keine Gelegenheit zu antworten.

Code:

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

Das dies zu Problem führt verstehe ich. Bei einem Aufruf von Confuses(42) weiß der Compiler nicht, ob er die erste Variante aufrufen soll, oder die zweite Variante mit der Defaultbelegung für den zweiten Paramter (Confuses(42, 0)). Dieses Problem tritt bei meinen Funktionen aber eigentlich nicht auf. Hier sollte anhand der Paramter immer ganz eindeutig klar sein, welche Funktion genutzt werden soll.

Um das Problem mit dem Default Paramter zu umgehen, habe ich noch eine weitere Funktion eingführt:

Delphi-Quellcode:

{#1} function GetString(ID: Integer): String; overload;
{#2} function GetString(ID: Integer; StringOptions: TStringOptions): String; overload;
{#3} function GetString(ID: Integer; Args: array of TVarRec): String; overload;
{#4} function GetString(ID: Integer; StringOptions: TStringOptions;
       Args: array of TVarRec): String; overload;

Wenn ich das Ganz nun mit folgenden Aufrufen teste, erhalte ich bei den 2, 3 und 4 die Meldung mit der doppeldeutigen Überladung:

Delphi-Quellcode:

// 1. Parameter (Integer) --> Funktion #1
str := GetString(42);

// 2. Parameter (Integer, TStringOptions) --> Funktion #2
str := GetString(42, [soQuoted]);

// 3. Parameter (Integer, TVarRec) --> Funktion #3
str := GetString(42, ['hallo']);

// 4. Parameter (Integer, TStringOptions, TVarRec) --> Funktion #4
str := GetString(42, [soQuoted], ['hallo']);

Soweit ich das verstehe ich eigentlich in jeder Situation durch die Parameter ganz eindeutig bestimmt, welche Funtkion genutzt werden soll.

Zitat von 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?

So wie bei jeder anderen überladenen Funktion auch: Durch die Zahl und den Typ der übrigen Paramter. Ich dachte eigentlich immer, dass sollte so funktionieren. Folgendes funktioniert prima obwohl der erste Parameter immer Integer ist:

Delphi-Quellcode:

function OverloadTest(ID: Integer): String;  overload;
function OverloadTest(ID: Integer; Str: String): String; overload;
..
OverloadTest(42);
OverloadTest(42, 'hallo');

Zitat von RavenIV:

Wenn Du bei der dritten Schreibweise den zweiten und dritten Parameter vertauschst, dann könnte es klappen.

Das änder leider nichts. Die Fehler treten ganz genauso auf.

Zitat von messie:

Aber die Deklarationen sollten mal ohne die gegenseitigen Aufrufe probiert werden. Vielleicht läßt sich das damit etwas entflechten.

Das Spielt keine Rolle. Dann tritt der Fehler auf, wenn man die Funktion im sonstigen Programm verwendet.

Zitat von 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.

Das funktioniert wirklich. Allerdings habe ich dann das Problem, dass ich alle Stelle an denen GetString(Integer; array of TVarRec) vorkommt ändern muss. Und das sind ziemlich viele.

Falls es gar nicht anders geht werde ich es also so machen. Wenn aber noch jemand eine Idee für eine elegantere Lösung hat wäre ich dafür wirklich dankbar!

Besten Dank
Ares