Funktion soll als Parameter verschiedene Datentypen akzeptieren

[Tenobaal]

Hallo,
ich möchte eine Funktion schreiben, die als Parameter "Value" verschiedene Datentypen (Integer, String, Single, Double) akzeptiert.
Die Funktion soll abhängig vom Datentypen von "Value" unterschiedliche Operationen ausführen.
Ich habe schon versucht "Value" als Pointer usw. zu deklarieren, aber der Kompiler ließ sich damit nicht austricksen.

Edit: Meine Delphi-Version ist Delphi 2007

Delphi-Quellcode:

function Speichern(s:String; var Value):Integer;
var
    ptrString:^String;
    ptrInteger:^Integer;
    ptrDouble:^Double;
    ptrSingle:^Single;
    error:Integer;
begin

 case VarType(Value) of //hier tritt ein Fehler auf

    VarInteger: Begin
      ptrInteger:=@Value;
      Val(s,ptrInteger^,error);
      ptrInteger:=nil;
      End;

    VarSingle: Begin
      ptrSingle:=@Value;
      Val(s,ptrSingle^,error);
      ptrSingle:=nil;
      End;

    VarDouble: Begin
      ptrDouble:=@Value;
      Val(s,ptrDouble^,error);
      ptrDouble:=nil;
      End;

    VarString: Begin
      ptrString:=@Value;
      s:=ptrString^;
      ptrString:=nil;
      error:=0;
      End;
    Else error:=1;
 end;
 result:=error;
End;

procedure TForm1.Button2Click(Sender: TObject);
var
  a:Double; 
  Fehler:Integer;
begin
  Speichern(Edit1.Text,a,Fehler); //Hier ist a vom Datentyp Double. Prinzipiell sollen aber auch alle der oben erwähnten Datentypen funktionieren.
end;

[Sir Rufo]

Du kannst Funktionen auch überladen

Delphi-Quellcode:

procedure foo( var Value : string ); overload;
procedure foo( var Value : Integer ); overload;

[grl]

Zitat von Tenobaal:

Delphi-Quellcode:

function Speichern(s:String; var Value):Integer;
var
    ptrString:^String;
    ptrInteger:^Integer;
    ptrDouble:^Double;
    ptrSingle:^Single;
    error:Integer;
begin

 case VarType(Value) of //hier tritt ein Fehler auf

und was für ein Fehler?

Zitat von Tenobaal:

Delphi-Quellcode:

    VarInteger: Begin
      ptrInteger:=@Value;
      Val(s,ptrInteger^,error);
      ptrInteger:=nil;
      End;

^Integer ist nicht das gleiche wie ein Pointer auf Value.
wenn du ein Variant verwendetest in dem ein Integer gespeichert ist, kannst du es einfach einem Integer zuweisen.

also:

Delphi-Quellcode:

var iWert:Integer;

if VarType(Value)=varInteger then begin
  iWert:=Value;
end;

Zitat von Tenobaal:

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var
  a:Double; 
  Fehler:Integer;
begin
  Speichern(Edit1.Text,a,Fehler); //Hier ist a vom Datentyp Double. Prinzipiell sollen aber auch alle der oben erwähnten Datentypen funktionieren.
end;

Die Definition von Speichern function Speichern(s:String; var Value):Integer; hat aber keinen Parameter für Fehler. Wie soll das gehen?

Gruß
Luggi

[Furtbichler]

In der Deklaration procedure Foo(Var Bar) ist 'Bar' kein Variant und deshalb führt die Verwendung in 'varType' zu einem Fehler.

Ändere die Deklaration in function Speichern(s:String; Value : Variant):Integer; und Du hast weniger Probleme.

[Tenobaal]

Danke für eure Antworten! Ihr habt mir schon sehr geholfen.

Zitat von grl:

Die Definition von Speichern function Speichern(s:String; var Value):Integer; hat aber keinen Parameter für Fehler. Wie soll das gehen?

Ja, du hast recht. Ich war zu voreilig und hab den Quellcode von der Funktion "Speichern" geändert ohne das Button-Ereignis anzupassen.

Wenn ich das richtig Verstanden habe gibt es zwei Ansätze:
1) Mit dem Datentyp Variant arbeiten. Führt aber dazu, dass ich Variablen hin und her kopieren muss

Delphi-Quellcode:

function Speichern(s:String; var Value:Variant):Integer;
var help_int:Integer;
begin
 case VarType(Value) of

    VarInteger: Begin
      Val(s,help_int,result);
      Value:=help_int;
      End;
     (*
     .
     .
     .
     .
     .
     *)
    Else result:=1;
 end;

End;

procedure TForm1.Button2Click(Sender: TObject);
var
  a:Integer;
  aVar:Variant;
begin
  aVar:=a;
  Speichern(Edit1.Text,aVar);
  a:=aVar;
end;

2) Für jeden Datentyp eine eigene Funktion überladen (wusste nicht, dass es möglich ist). Dann nimmt mir der Kompiler die Arbeit ab, sodass keine Typ-Unterscheidung meinerseits nötig ist.

Delphi-Quellcode:

function Speichern(s:String; var Value:Integer):Integer; overload;
begin
      Val(s,Value,result);
End;

function Speichern(s:String; var Value:Double):Integer; overload;
begin
      Val(s,Value,result);
End;

function Speichern(s:String; var Value:Single):Integer; overload;
begin
      Val(s,Value,result);
End;

function Speichern(s:String; var Value:String):Integer; overload;
begin
      Value:=s;
      result:=0;
End;

procedure TForm1.Button2Click(Sender: TObject);
var
  a:Double;
  b:Single;
  c:String;
begin
  Speichern(Edit1.Text,a);
  Speichern(Edit1.Text,b);
  Speichern(Edit1.Text,c);
end;

[grl]

Wobei ich das Überladen für die schönere Variante halte...

Luggi

[Sir Rufo]

Zitat von grl:

Wobei ich das Überladen für die schönere Variante halte...

Luggi

Fehler bei der Benutzung werden auch schon bei der Compilierung erkannt

[Der schöne Günther]

Und wer weiß, was dieser gruselige Nullzeiger-Typ Variant noch alles für Überraschungen bereitgehalten hätte. Vielleicht ist das aber auch nur meine Paranoia...