typenloser parameter

[mumu]

ich habe folgende funktion:

Delphi-Quellcode:

function Write(para1: string; para2: string; para3: string; typ: integer; const right_value): boolean;

test: string;
test2: integer;

test := string(right_value);
test2: integer(right_value);

und ich möchte jetzt, dass ich bei right_value entweder einen string oder einen integer übergebe und je nachdem möchte ich dann was bestimmtes machen. ist doch eigentlich total simpel. ich weiß blos nicht, warum das nicht geht.

weiß jemand warum ich da falsche werte rausbekomm? mir wärs eigentlich auch lieber, wenn ich bei right_value nicht erst ne variable deklarieren muss und diese einen wert zuweisen, sondern die funktion z.b. so aufrufen kann:

Write('test', 'test', 'test', 1, 3); gibts da auch ne möglichkeit? wie mach ich das am besten?

[mumu]

also ich hab jetzt festgestellt, dass es bei mir ganz wo anders hakt.

jetzt mal ne allgemeine frage:
ich will an mein object Fehler im Create eine wert übergeben. dieser wert kann von verschiedenem typ sein. also integer, string, usw...

ich möchte den wert dann in der instanz der klasse speichern und beim aufruf einer funktion wieder ausgeben.

mein problem ist nur, wenn ichs mit pointer mach, dann ist ja der wert nachdem meine lokale variable wieder freigeben wird, weg...

Beispiel:

Delphi-Quellcode:

function FormShow();
var int: integer;
begin
   int := 3;
   fehler := TFehler.Create(@int);
end;

type
  TFehler = class
    public
      constructor Create(ptr: Pointer);
    private
      _value: pointer;
end;

constructor TFehler.Create(value: Pointer);
begin
  _value := value;
end;

ich hoff ihr versteht mich, wie ich das mein.

[Sharky]

Hai mumu,

arbeite doch mit einer überladenen Funktion:

Delphi-Quellcode:

function Write(para1 , para2 , para3: string; typ: integer; right_value : String): boolean; Overload;
begin
  //
end;

function Write(para1 , para2 , para3: string; typ: integer; right_value : Integer): boolean; Overload;
begin
  //
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  Write('test', 'test', 'test', 1, 'blubb');
  Write('test', 'test', 'test', 1, 3);
end;

[mumu]

ja gut, das ist klar, aber mir gehts eher ums prinzip, ob das überhaupt geht

und ich will jetzt nicht 20 überladene funktionen für jeden parameter-typ erstellen. und ich will auch nicht in der klasse 20 lokale variablen mit einem verschiedenen typ anlegen, um den übergabe-wert zu speichern.

gibts da ne möglichkeit?

danke schonmal

[mschaefer]

Moin, Wochenendmoin,

tja - dann kannst Du nur einen Variant nehmen. Nicht unbedingt beleibt bei den Pascalanhängern, aber es ist möglich. Oder Du übergibtst einen Record der aus einem String und einer Floatvariable sowie einer Boolean als Entscheidungsvariable welcher der beiden anderen gerade Gültigkeit hat.

Grüße // Martin

[SirThornberry]

oder du übergibst einfach einen Pointer auf den Wert.

[mumu]

variant genau das war das, was ich gesucht hab. warum werden denn variant nicht gern gesehen? welche nachteile haben die?

[SirThornberry]

variant ist nicht gern gesehen (von mir) weil es den unter d3 noch nicht gibt und auch für dll-proceduren (manchmal muss man ja auch ne funktion exportieren) sind die nicht geeignet wenn man mit anderen programmiersprachen aggiert. deswegen sind da pointer etc. besser.

[mschaefer]

Moin, mon,

ja ich kann SirThomberry da schon verstehen, sehe das aber etwas lockerer. Prinzipiell sind Variants einfach langsamer als die Ursprungsvariablen und nochmal langsamer als Pointerlösungen.

Das es die nicht unter D3 gibt ist für mich eigentlich nicht mehr relevant, denn meine Programme laufen schon unter D4 nicht mehr sauber durch den Compiler. Borland hat da inzwischen einfach sinnvoller Änderungen gemacht und die möchte ich nicht missen.

Wenn man mit OLE arbeitet kommt man um die Variants, aufgrund der Microsoft-Implementierung, prinzioiell nich umhin. Deshalb hat sie auch Borland eingeführt. Da Pointer in VB nicht vorhanden sind und man oft mit globalen Variablen den Überblick verliert ist der Varianttyp hier willkommen.

In Delphi ist die Weitergabe von Pointern der schnellste Werg um auf Daten zuzugreifen. Aber der Pointer alleine reicht nicht. Man braucht noch eine zweite Variable um die Information zu liefern um was für einen Datentyp es sich handelt. Oft muß man dann wieder mit Case-Strukturen arbeiten um mit dem richtigen Typ dann weiterzuarbeiten, was auch nicht umbedingt elegant ist.

FAZIT: Wenn irgend möglich baue Deine Funktionen so, dass Sie wissen mit was Sie umgehen sollen und vermeide Variant. Wenn es aber einfach in der Problemstellung liegt, dass man nicht weiss um welchen Datentyp es sich handelt den man bearbeiten muß, dann sind Variants vertretbar.

Grüße /// Martin