Rueckgabewerte von ueberladenen Funktionen?

[DevilsCamp]

Delphi-Quellcode:

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

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

  Test('Servus');    // <---- hier sollte der Compiler dann meckern und sonst nicht ;)
end;

Könnten wir uns auf obigen QuellCode einigen?

[leddl]

Klar könnten wir uns einigen, nur der Compiler wird trotzdem schon vorher meckern

[DevilsCamp]

Leider.

Wird mir wohl wirklich nichts anderes übrig bleiben als den Funktionsnamen zu ändern

[barf00s]

Falls ihr dennoch auf Variants setzt, dann verwendet auch die Funktionen aus der Variants.pas, mit denen man den Inhalt dieser Variablen prüfen - oder deren internen Typ abfragen, was zur Fehlerbehandlung beitragen sollte. </sülz>

Ansonsten sollte man Variants allerdings vermeiden - aus besagten Gründen

[DevilsCamp]

oder ich benutze statt einer Funktion eine Prozedur und übergebe die Variable, in der das Ergebnis stehen soll als var-Parameter

Delphi-Quellcode:

procedure Test(Bla: String; var Result: String); overload;
procedure Test(Bla: String; var Result: Integer); overload;

[BlackJack]

@DevilsCamp: wundert mich dass diese Methode nicht schon viel eher vorgeschlagen würde, die kam mir beim lesen des threads als aller erstes in den sinn

[barf00s]

prozeduren sind ohnehin 800% schneller als funktionen, in der verarbeitung

[SubData]

Zitat von barf00s:

prozeduren sind ohnehin 800% schneller als funktionen, in der verarbeitung

Kannst du diese Aussage bitte begründen?

(Ich will dich damit nicht anprangern, sondern es interessiert mich wirklich, warum das so ist / sein soll)

[Dax]

@barf00s: Warum erzählst du solchen Unsinn?

Kuck dir das mal an:

Delphi-Quellcode:

program Project5;

uses
  Windows;

{$APPTYPE CONSOLE}

function TestF(I: Integer): Integer;
begin
  Result := I + 1;
end;

procedure TestP(I: Integer; var Result: Integer);
begin
  Result := I + 1;
end;

var
  Dump, I: Integer;
  _Begin, _End, _Dif: Int64;

begin
  Dump := 0;
  QueryPerformanceCounter(_Begin);
  for i := 0 to 10000000 do
    Dump := TestF(Dump);
  QueryPerformanceCounter(_End);
  _Dif := _End - _Begin;
  WriteLn('Functiontest : ', _Dif, ' Ticks');
  Dump := 0;
  QueryPerformanceCounter(_Begin);
  for i := 0 to 10000000 do
    TestP(Dump, Dump);
  QueryPerformanceCounter(_End);
  _Dif := _End - _Begin;
  WriteLn('Proceduretest: ', _Dif, ' Ticks');
  Readln;
end.

Und das Ergebnis, das dabei rauskommmt:

Zitat:

Functiontest : 165575 Ticks
Proceduretest: 326003 Ticks

Ich würde doch mal sehr behaupten, Prozeduren seien langsamer

Edit: Copy&Waste

[DevilsCamp]

was hast du für einen Rechner?


Bei mir kommt folgendes raus:

Code:

Functiontest         Proceduretest
      471782                383582
      481778                406912
      473677                384258
      487796                381966
      488406                384659
      480697                402065
      479277                384486
      481221                377313
      475937                377417
      475279                402056

Bei mir sind die Procedures schneller