funktion aufrufen deren namen in einem string steckt

[griever]

ok das ergibt sinn
dann fällt mir jetzt nur noch ein das ich den inhalt des strings als name für die variable (welche den pointer auf die funktion hat) z.B.:
string := 'abc';
abc := @funktion;

nur wie komme ich jetzt mit den namen der variablen im string an deren inhalt?

[himitsu]

Zitat von griever:

nur wie komme ich jetzt mit den namen der variablen im string an deren inhalt?

siehe oben

Delphi-Quellcode:

type TMyFunc = function(b: Byte);
  TMyArray = array of record
    name: String;
    func: TMyFunc;
  end;
var a: TMyArray;

function TestFunc(b: Byte);
begin
end;


SetLength(a, 1);
a[0].name := 'Test';
a[0].func := TestFunc; // 1

for i := 0 to High(a) do
  if a[i].name = {'Test'} then begin
    x := a[i].func({123});
    Break;
  end;

1: falls sich da wer wundert, daß dort nicht @TestFunk steht ... Delphi erkennt, daß Links ein Funktionszeiger erwartet wird und weiß, daß ich den Zeiger zur Funktion zuweisen will.

[griever]

ok bin mir sicher das das funktioniert aber gibt es keinen befehl in delphi der direkt den inhalt eines stringes als name umwandelt (außer das findcomponents) weil sonst kann ich auch gleich
if string = 'abc' then abc(a,b); machen nur find ich das nicht "optional"

[jfheins]

Erstelle eine Superklasse, die alle Methoden als published Property hat - dann kannst du mit der RTTI darauf zugreifen und eine Methode aufrufen, deren namen du im String hast.

Was soll das eigentlich mal werden? Vll. gibts da bessere Lösungen ...

[himitsu]

Zitat von griever:

ok bin mir sicher das das funktioniert aber gibt es keinen befehl in delphi der direkt den inhalt eines stringes als name umwandelt (außer das findcomponents) weil sonst kann ich auch gleich if string = 'abc' then abc(a,b); machen nur find ich das nicht "optional"

Was denkst du eigentlich, was FindComponent macht?

Das geht auch nur die in der Form registrierten Komponenten durch, welche auch in einer Art Array/Liste dort gespeichert sind.

Delphi-Quellcode:

function TComponent.FindComponent(const AName: string): TComponent;
var
  I: Integer;
begin
  if (AName <> '') and (FComponents <> nil) then
    for I := 0 to FComponents.Count - 1 do
    begin
      Result := FComponents[I];
      if SameText(Result.FName, AName) then Exit;
    end;
  Result := nil;
end;

[Uwe Raabe]

Es ist zwar schon mehrfach angesprochen worden, aber hier mal ein konkretes Beispiel. Der Einfachheit halber geben die Funktionen lediglich einen Integer-Wert zurück:

Delphi-Quellcode:

type
  TMyFunc = function: Integer of object;

function CallObjectFunction(Instance: TObject; const FuncName: string): Integer;
var
  Func: TMyFunc;
  MVar: TMethod;
begin
  MVar.Data := Instance;
  MVar.Code := Instance.MethodAddress(FuncName);
  Assert(Assigned(MVar.Code));
  Func := TMyFunc(MVar);
  result := Func();
end;

type
{$METHODINFO ON}  // falls das nicht geht, müssen die Methoden published sein!
  TTestObject = class
  public
    function Test1: Integer;
    function Test2: Integer;
  end;

function TTestObject.Test1: Integer;
begin
  result := 42;
end;

function TTestObject.Test2: Integer;
begin
  result := 4711;
end;

procedure TestIt;
var
  res: Integer;
  TestObject: TTestObject;
begin
  TestObject := TTestObject.Create;
  try
    res := CallObjectFunction(TestObject, 'Test1');
    Assert(res = 42);
    res := CallObjectFunction(TestObject, 'Test2');
    Assert(res = 4711);
  finally
    TestObject.Free;
  end;
end;

[himitsu]

Und .MethodAddress macht genau das Selbe wie die anderen Vorschläge ... es durchsucht eine Liste nach den Namen und gibt einen Zeiger auf dessen zugeordnete Funktion zurück.

[Blup]

Abhilfe schafft nur ein Precompiler, wie er z.B. in den meisten Basic-Dialekten eingesetzt wird.
Dieser würde die Funktionsaufrufe durch Token mit der entsprechenden Adresse oder Nummer ersetzen.
Dadurch wird dann die eigentliche Ausführung schneller.