Hallo!
Stehe grad vor folgenden Problem:
Wir haben eine Klasse A und eine Klasse B gegeben. Von Klasse B erzeugen wir jedoch mehrere Instanzen, welche alle in den Arbeitsablauf einer Instanz der Klasse A integriert werden sollen.
Ich hab mir dazu überlegt, dass man einfach die zu integrierenden Methoden von Klasse B als Pointer in einer Liste von Klasse A speichert. Klasse A könnte dann einfach die Liste durchgehen und die Methoden aufrufen.
Es ist nicht so, dass ich auch andere Wege wüsste ^^, aber mich würde mal interessieren, wie das geht, schließlich macht man das auch irgendwie so bei einem dynamischen Funktionsaufruf einer DLL...
Habs schon mal versucht, aber ich bekomm leider das speichern der Prozeduren-Zeiger nicht hin ...

Moin!

Wieso merkst du dir nicht einfach alle Instanzen von Klasse B in Klasse A in einer TObjectList. Klasse A sollte dazu z.b. im Konstruktor einfach Klasse B aufrufen und ihr Self übergeben, damit Klasse A die TObjectList füllen kann. Wenn du nun eine Methode in allen Instanzen von Klasse B nacheinander aufrufen willst, dann laufe über alle Einträge in der TObjectList und rufe die Methode auf.

Instanzenvariablen sind intern schon Zeiger. Die TObjectList hat somit Referenzen auf die Klasseninstanzen - somit brauchst du keine Zeiger mehr auf die einzelnen Methoden.

MfG
Muetze1

zusammenfalten · markieren

Delphi-Quellcode:

type tproctype = procedure (e:integer);

procedure a(w:integer);
begin

end;

procedure TForm1.Button1Click(Sender: TObject);
 var e:pointer;
begin
 e := @a;
 tproctype(e)(2);
end;

Oder du benutzst TList

Moin!

Das ist dann aber ein Procedurezeiger und kein Methodenzeiger....

Somit wär's ein Methodenzeiger:

zusammenfalten · markieren

Delphi-Quellcode:

type tproctype = procedure (e:integer) of object;

procedure TForm1.a(w:integer);
begin

end;

procedure TForm1.Button1Click(Sender: TObject);
var e:tproctype;
begin
e := a;
e(2);
end;

MfG
Muetze1

Richtig. Ein Fehler von mir.

zusammenfalten · markieren

Delphi-Quellcode:

type tproctype = procedure (Sender:TObject);

procedure a(Sender:TObject);
begin
 ShowMessage('Klick');
end;

procedure TForm1.Button1Click(Sender: TObject);
 var e:pointer;
     m : TMethod;
begin
 m.Code := @a;
 m.Data := self;
 OnClick := TNotifyEvent(m);
 e := @a;
end;

@sniper_w:
Wie gesagt, andere Wege sind mir bekannt, aber ich wähle diesen, weil er irgendwie Klasse hat *g*.

Bei mir siehts zurzeit so aus:

markieren

Code:

type
  TProc = procedure;
...
constructor TKlasseB.Create(A: TKlasseA);
  var P: TProc;
begin
  P:=Self.Proc;
  A.List.Add(@P);
end;

procedure TKlasseB.Proc;
begin
  //bla
end;

...

procedure TKlasseA.Abarbeiten;
  var I: Integer;
begin
  for I := 0 to List.Count-1 do TProc(List[I]^);
  //hier kommt ne hübsche EAccessViolation
end;

Zitat von MaOfDe:

Wie gesagt, andere Wege sind mir bekannt, aber ich wähle diesen, weil er irgendwie Klasse hat *g*.

Kein Kommentar

Ändere mal folgendes

markieren

Code:

type
  [s]TProc = procedure;[/s]
  TProc = procedure of object;

......

Zitat:

markieren

Code:

type
  TProc = procedure;
  TProc = procedure of object;

sry klappt auch nicht.

Zitat von MaOfDe:

sry klappt auch nicht.

Stimmt, weil die Objekt-Referenz bereits nicht mehr gegeben ist Mache es also doch lieber nach Standard OOP Ansätzen wie oben beschrieben

......

TProc(List[I]^) Falsch, es wird nicht dereferenziert und es fehlt der implizite Self Parameter.

Nimm den OOP Ansatz, der macht das alles für dich automatisch, typsicher, ohne manuelle Zeigerarithmetik, ist genauso effizient und gerade für Anfänger besser geeignet. Besonders der Punkt der zeitlichen Gültigkeiten der verlinkten Methoden kannst du über die Object Liste viel besser erschlagen.

Gruß Hagen