Funktionsnamen aus Variablen?

[new32]

Gibt es eine möglichkeit eine Funktion auszuführen, deren Name in einer Variable steht?

z.B.:

Delphi-Quellcode:

var s:string;

procedure h;
begin
 //???
end;

s:=h;

so und nu möchte ich dieses hier anders machen:

Delphi-Quellcode:

if s=h then h;

[Dax]

Ja, die Möglichkeit gibt es. Aber sie wird von Delphi nicht angeboten. Das ganze Ding, das du brauchst, nennt sich Parser, damit könnte es gehen ;)

Falls du das wirklich über Strings machen willst, schlage ich vor, deine Prozeduren als class procedures in eine Klasse zu legen (unter published) und per RTTI anzusprechen.

[Oxmyx]

Nein, es gibt keine triviale Möglichkeit, das zu tun was du erreichen willst. Ich weiß allerdings nicht, was an einer if-Abfrage schlecht sein soll.

[new32]

Zitat:

Zitat von Oxmyx

Ich weiß allerdings nicht, was an einer if-Abfrage schlecht sein soll.

Ich baue nen Interpreter; wenn ich nu für jeden Befehl ne if-Abfrage(oder case...) mache, bin ich 1. ewig damit bescheftigt und 2. wird das ding immer langsamer!


verstehst du mein Problen?

MfG NEW32!

[Speedmaster]

Stichwort: Funktions und Methodenzeiger!

[Pseudemys Nelsoni]

Und wie sollen ihm Methodenzeiger dort helfen? Per string kann er sie damit trotzdem nicht ansprechen bzw aufrufen.

[new32]

versteh ich auch nich.

ich stell mir das so vor(vereinfacht):

Delphi-Quellcode:

runProc('h');

[MrKnogge]

Die procedure-Namen die du in Delphi gibst, gibt es aber später im programm nicht mehr, sie dienen lediglich zum programmieren, folglich wirst du um if / case nicht drumrum kommen.

[negaH]

Es gibt tatsächlich zwei Möglichkeiten die in Delphi integriert sind um das zu erreichen:

1.) über Klassen deren Methoden published wurden. Über Class.FindMethod() kann man solche published Methoden finden und aufrufen. Deren Parameter müssen aber denoch zur Compilertime bekannt und fixiert sein.

2.) über Interfaces, genauer gesagt über IDispatch. Benutzt man solche Interfaces dann gibt es bekanntlich zwei Arten der Bindung solcher Interfaces -> die frühe Bindung ist hardcoded durch den Compiler aber die späte Bindung basiert auf Namen. Vorteil dieser Variante ist es das die Parameter selber ebenfalls dynamisch zu Laufzeit übergeben werden können und denoch Typsicher sind.

In jedem Falle müssten deine Proceduren/Funktionen in Klassen oder Interfaces gekapselt werden, was ich sogar als Vorteil empfinde. Die letztere Art kann zb. auch mit dem MS-Scripting benutzt werden. D.h. man kann zb. in VBA Basci seine Scripte schreiben, in Delphi seine eigenen IDispatch Schnittstellen implementieren und diese dann innerhalb der Scripting Engine aufrufen.

Gruß Hagen

[new32]

Zitat:

Zitat von MrKnogge

Die procedure-Namen die du in Delphi gibst, gibt es aber später im programm nicht mehr, sie dienen lediglich zum programmieren, folglich wirst du um if / case nicht drumrum kommen.

Da is was dran... hätt ich eigentlich selbst drauf kommen können.

@all: TNX!

[idontwantaname]

da gibt es noch eine möglichkeit, wenn auch eine ziemlich "schmutzige"
wenn die funktionen/proceduren alle die selben parameter haben, könntest du diese in einer DLL implementieren und sie dann zur Laufzeit einbinden
genaueres hier
natürlich ist das eine bedingt verwendbare möglichkeit, und hagens ist sicher besser :wink:

[KLS]

es gibt eine recht einfache möglichkeit

Delphi-Quellcode:

procedure StarteRoutineByName(Instance : TObject; Name : string);  //instance z.b. Form1
type
  TExecute = procedure of object;
var
  Routine : TMethod;
  Execute : TExecute;
begin
  Routine.Data := Pointer(Instance);
  Routine.Code := Instance.MethodAddress(Name);
  if Routine.Code = nil then Exit;
  Execute := TExecute(Routine);
  Execute;
end;

und damit die sache perfekt ist

Delphi-Quellcode:

function FindFormByName(Formname : string) : Tform;
var
  i : byte;
begin
  result := nil;
  for i := 0 to screen.FormCount-1 do if screen.Forms[i].Name = Formname then
  begin
    result := screen.Forms[i];
    break; 
  end;
end;

[new32]

@idontwantaname: nette Idee, aber nen bisschen umständlich. :wink:

@KLS: sieht interessant aus!

[SirThornberry]

zum vorschlag von idontwantaname: Man muss die Funktionen nicht in eine DLL auslagern. Man kann auch einfach im Hauptprogramm exports aufführen und somit findet man die procedure auch über GetProcAddress

[idontwantaname]

Zitat:

Zitat von SirThornberry

zum vorschlag von idontwantaname: Man muss die Funktionen nicht in eine DLL auslagern. Man kann auch einfach im Hauptprogramm exports aufführen und somit findet man die procedure auch über GetProcAddress

ahhh, stimmt !

aber die lösung von KLS gefällt mir auch ganz gut

[-=IOI=-]

ich würde gerne die variante von KLS verwenden, aber leider funktioniert das bei mir nicht.

ich habe eine procedure

Delphi-Quellcode:

procedure schließen;
begin
  Form1.Close;
end;

wenn ich diese aber mit

Delphi-Quellcode:

StarteRoutineByName(Form1,'schließen');

aufrufe, passiert garnichts.

die StarteRoutineByName procedure hab ich 1 zu 1 übernommen.

was mache ich falsch?

[mkinzler]

schließen ist laut deiner Deklaration auch eine freie Pozedur und keine Methode von TForm1

[KLS]

und ausserdem nimmt der das ß nicht. Das ist ein ungültiges zeichen.

so wird ein schuh draus.

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, SysUtils, Classes, Controls, Forms, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure schliessen;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure StarteRoutineByName(Instance : TObject; Name : string);
type 
  TExecute = procedure of object; 
var 
  Routine : TMethod; 
  Execute : TExecute; 
begin 
  Routine.Data := Pointer(Instance); 
  Routine.Code := Instance.MethodAddress(Name); 
  if Routine.Code = nil then Exit; 
  Execute := TExecute(Routine); 
  Execute; 
end;

procedure TForm1.schliessen;
begin 
  Close;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  StarteRoutineByName(Form1,'schliessen');
end;

end.

[-=IOI=-]

danke euch, so klappt es wunderbar.

es lag hauptsächlich an dem 'ß', weil mit TForm1 hatte ich es auch schonmal probiert.
wundert mich aber, dass der compiler, da nicht rummeckert. Naja, seis drum.

Eine Frage hätte ich noch. was muss ich noch abändern, wenn ich der aufzurufenden funktion auch noch einen oder mehrer parameter übergeben muss?

[mkinzler]

Zitat:

wundert mich aber, dass der compiler, da nicht rummeckert. Naja, seis drum.

Er optimiert die Sonderzeichen halt weg.

[KLS]

wie auch immer, vielleicht hab ich andere einstellungen, aber bei mir meckert der bei ä,ö,ü,ß auf jeden fall.

[Hawkeye219]

Es liegt nicht an den Einstellungen und es wird auch nichts wegoptimiert. Seit Delphi 2005 ist es möglich, Umlaute und das "ß" in Bezeichnern zu verwenden. Ich vermute daher, daß -=IOI=- eine neuere Delphi-Version verwendet. Sein Profil sagt leider nichts darüber aus.

Gruß Hawkeye

[-=IOI=-]

ich nutze delphi 2005 personal.
trotzdem schien es ja an dem 'ß' zu liegen, da es nach einer änderung in 'ss' funktionierte.

lieber wär mir allerdings eine lösung für mein parameter problem :wink:

[KLS]

vielleicht nicht das beste, aber so geht es auf jeden fall mit einfachen variablen.

Delphi-Quellcode:

var
  wartezeitschliessen : integer;

procedure TForm1.schliessen;
begin
  sleep(wartezeitschliessen); //nur als beispiel
  Close;
end;

procedure TForm1.Button1Click(Sender: TObject);
const
  s = 'schliessen 5000';
var
  sp,st : string;
begin
  sp := copy(s,1,pos(' ',s) - 1); //schliessen
  st := copy(s,pos(' ',s) + 1,length(s)); //5000
  wartezeitschliessen := strtoint(st); //globale variable!
  StarteRoutineByName(Form1,sp);
end;

[-=IOI=-]

super, ich danke dir.
da ich nach derzeitigem stand nur einfache variablen übergeben muss, reicht das vollkommen aus.