Rueckgabewerte von ueberladenen Funktionen?

[alcaeus]

Hallo allerseits,

im anderen Thread habe ich ja ein Optionssystem angesprochen. Um die Optionswerte zu holen, wollte ich eigentlich Methoden verwenden, die auch schon den entsprechenden Typecast (von String) vornehmen. Allerdings scheint das mit den ueberladenen Methoden nicht zu funktionieren:

Delphi-Quellcode:

function GetOption(iOptionConst: Integer): String; overload;
function GetOption(iOptionConst: Integer): Integer; overload;

In der zweiten Zeile schimpft der Compiler: "Declaration of GetOption differs from previous declaration". Dass sich die Deklarationen sich unterscheiden ist mir klar, aber sollte das nicht der Sinn und Zweck von ueberladenen Funktionen sein?
Oder muessen sich etwa die Parameterlisten unterscheiden? Wenn ja, wie sollte ich das sonst machen? Die Optionswerte werden als String abgespeichert und es waere natuerlich geschickt wenn ich eine Funktion habe, die mir direkt den gewuenschten Wert auf den richtigen Typ castet und zurueckgibt.
Kann mir jemand helfen?

Thanx and Greetz
alcaeus

[jim_raynor]

Ja, bei Überladenene Funktionen müssen sich die Parameter unterscheiden, denn sonst weiß der Compiler nicht welche Funktion genutzt werde soll. Entweder nutzt du Variants (was natürlich wesentlich langsamer ist) oder du musst einfach die Funktionen unterschiedlich benennen, so wie es bei verschiedenen Inkarnationen von TRegistry und ähnlichem der Fall ist.

[alcaeus]

Na gut, dann werde ich wohl mit solchen "Aushilfsmethoden" arbeiten (muessen).

Greetz
alcaeus

[SubData]

Ich verwende dafür nen Variant, das geht auch wunderbar

Delphi-Quellcode:

function Config(Section, Value: String; Default: Variant; Typ: String = 'V'): Variant; Overload;
var
  Read : Variant;
  ReadInt : Integer;
begin
  // Einen Konfigurationswert zurückgeben...
  if (Typ <> 'R') then Read := CfgValues.Values[Section + '_' + Value];
  if (Typ = 'R') then
  begin
    Read := CfgRegExp.Values[Section + '_' + Value];
    if not (Read <> '') then Read := Default;
    if not (Read <> '') then Read := '$';
    Result := Read;
  end;
  if ((Typ = 'V') or (Typ = 'S')) then
  begin
    if not (Read <> '') then Read := Default;
    Result := Read;
  end;
  if (Typ = 'B') then
  begin
    Result := Default;
    if (Read = '1') then Result := True;
    if (Read = '0') then Result := False;
  end;
  if (Typ = 'I') then
  begin
    if not (TryStrToInt(Read, ReadInt)) then Result := Default
    else Result := ReadInt;
  end;
end;

Edit: Es gibt die Funktion nochmal deswegen der Overload...

Delphi-Quellcode:

function Config(Section, Value: String; Typ: String = 'V'): Variant; Overload;
begin
  Result := Config(Section, Value, '', Typ);
end;

[alcaeus]

Zitat von SubData:

Ich verwende dafür nen Variant, das geht auch wunderbar

Ja, allerdings moechte ich die Verwendung von Variants soweit wie moeglich vermeiden, weil Fehler nicht ganz so ersichtlich sind. Ich behalte deine Loesung aber mal im Hinterkopf.

Greetz
alcaeus

[SubData]

Aus dem Grund kannste ja den Typ angeben der zurück gegeben werden soll

Aber hast schon Recht, ich versuche auch weitgehend auf Variants zu verzichten :>

[DevilsCamp]

Da ich gerade das selbe Problem habe habe ich diesen Thread gefunden

Zitat von jim_raynor:

Ja, bei Überladenene Funktionen müssen sich die Parameter unterscheiden, denn sonst weiß der Compiler nicht welche Funktion genutzt werde soll. Entweder nutzt du Variants (was natürlich wesentlich langsamer ist) oder du musst einfach die Funktionen unterschiedlich benennen, so wie es bei verschiedenen Inkarnationen von TRegistry und ähnlichem der Fall ist.

Ich habe folgenden Code:

Delphi-Quellcode:

interface
  function Test(Bla: String): String; overload;
  function Test(Bla: String): Integer; overload;

implementation

function Test(Bla: String): String;
begin
  Result := 'Hallo '+Bla;
end;

function Test(Bla: String): Integer;
begin
  Result := StrToIntDef(Bla, 0);
end;

procedure Hallo;
var
  i : Integer;
  s : String;
begin
  s := Test('Peter');
  i := Test('12345');
end;

end.

Der Compiler weiß doch, dass s ein String und i ein Integer ist. Wieso ist er also nicht in der Lage herauszufinden, dass s die Funktion benötigt, die ein String zurückgibt und i die entsprechende Integer-Variante?

Das das bei Prozeduren mit selben Parametern nicht funktionieren kann ist klar, aber bei Funktionen ist diese Einschränkung doch etwas unlogisch.

Ich verweise da mal auf die nette Funktion Explode aus der Code-Library. Die gibt dort ein String-Array zurück. Genauso gut kann man die aber auch so umschreiben, dass ein Integer-Array zurück gegeben wird. Und das bei der selben Parameter-Liste.

Und genau das ist z.Z. mein Problem.
Dass ich die Funktion wohl nicht beliebig nutzen kann, nur weil der Compiler es nicht mag, wenn nur der Ergebnis-Typ unterschieldich ist

[mirage228]

Hi,

Diese Entscheidung kann der Compiler nicht (immer) treffen.

Was sollte er denn in diesem Fall tun:

Delphi-Quellcode:

var
  V: Variant;
begin
  V := Test('Peter');
end;

Soll er nun einen Integer oder String zurückgeben?

Es wäre zu zeitaufwendig für den Compiler immer herauszufinden, in welchem Kontext die Funktion benutzt wird. Bei Parametern ist es da einfacher.

mfG
mirage228

[leddl]

Außerdem könnte man theoretisch die Funktion auch ohne Zuweisung aufrufen.

[Robert_G]

Zitat von leddl:

Außerdem könnte man theoretisch die Funktion auch ohne Zuweisung aufrufen.

Richtig!
Genau deshalb gehört der Rückgabewert nicht zur Signatur einer Funktion. (Ein Prozedur ist ja auch nur ein Funktion, die nüscht zurückgibt )
Da für Overloads die Signatur eindeutig sein muss, sollte klar sein warum das nicht geht.