Übergabe Funktion an Constructor

[Joh]

Moin,

wenn ich eine Komponente im Code erstelle, kann ich ja die Ereignisprozedur mit

Code: Alles auswählen

komponente.OnChange := @setFilter;

zuweisen.
Wie übergebe ich dann die Funktion im Constructor, wenn ich die Ereignisprozedur mit übergeben will?

Der Aufruf

Code: Alles auswählen

constructor Create (AOwner: TComponent; ...; ptr: Pointer);

mit

Code: Alles auswählen

sf := TmyFeld.Create(self, ..., @setFilter);

wirft mit einen Error: Incompatible type for arg no. 4: Got "<procedure variable type of procedure(TObject) of object;Register>", expected "Pointer".
Bisher war ich der Meinung, ein @setFilter entspricht einem Pointer auf die Funktion setFilter. Kann ich überhaupt die Prozedur übergeben?
Oder wäre der passendere Weg, im Construktor über AOwner.setFilter zu gehen?

Joh

(ich befürchte, man merkt, das hier jemand, der eigentlich prozedural programmiert, versucht, Objekte zu erzeugen...)

[Zvoni]

Ein OnChange-Ereignis hat ja in der Regel nen Datentyp "TNotifyEvent"
https://lazarus-ccr.sourceforge.io/docs ... event.html

Ungetestet

Code: Alles auswählen

sf := TmyFeld.Create(self, ..., Pointer(@setFilter));  //Harter Cast

Damit brauchst du aber wieder einen Cast zurück im Constructor, glaub ich zumindest

Oder das versuchen:

Code: Alles auswählen

constructor Create (AOwner: TComponent; ...; ptr: TNotifyEvent);

[Joh]

Oder das versuchen:

Code: Alles auswählen

constructor Create (AOwner: TComponent; ...; ptr: TNotifyEvent);

Danke! so funktionierts. Noch so schön

[Zvoni]

Oder das versuchen:

Code: Alles auswählen

constructor Create (AOwner: TComponent; ...; ptr: TNotifyEvent);

Danke! so funktionierts. Noch so schön

Denk dran: Das funktioniert dann insoweit, sofern die Events alle den gleichen Typ haben (TNotifyEvent).
Sollte ein Event mit einem anderen Datentyp ins Spiel kommen (andere Arguments-Liste), ist wohl das sinnvollste einen Constructor-Overload pro Datentyp zu machen

[Warf]

Bisher war ich der Meinung, ein @setFilter entspricht einem Pointer auf die Funktion setFilter. Kann ich überhaupt die Prozedur übergeben?
Oder wäre der passendere Weg, im Construktor über AOwner.setFilter zu gehen?

Es gibt verschiedene arten von Funktionspointern die sich in Kontext unterscheiden. Reine Funktionspointer ohne Kontext zeigen einfach nur auf ein stück Code. Die haben prozeduren typen:

Code: Alles auswählen

type
  TMyProcPointer = procedure(Arg: Integer);
  TMyFuncPointer = function(Arg: Integer): Integer);

Dann gibt es Methodenpointer, die zeigen auf Methoden von Klassen. Eine Methode wird immer im Kontext eines Objektes aufgerufen, was man über Self referenzieren kann. Intern sind methoden pointer tatsächlich einfach 2 pointer, einer zum Code und einer zum Objekt:

Code: Alles auswählen

type
  TMyProcMethodPointer = procedure(Arg: Integer) of object;
  TMyFuncMethodPointer = function(Arg: Integer): Integer of object;

Und es gibt in Pascal noch nested Funktionen, das sind Funktionen im Kontext einer anderen Funktion, die können z.B. auf die Lokalen Variablen der umgebenden Funktion oder deren Parameter zugreifen. Ein Nested Funktionspointer enthält einen Pointer auf den Stack der umgebenden funktion, und den Pointer in den Code:

Code: Alles auswählen

type
  TMyNestedProcPointer = procedure(Arg: Integer) is nested;
  TMyNestedFuncPointer = function(Arg: Integer): Integer is nested;

Zu guter letzt gibts dann noch Funktions Referenzen, das sind Closures die ihren state in einem eigenen Objekt capturen. Intern sind das eigentlich einfach Objekte mit einer Invoke methode. Alle oben genannten funktionspointer typen können in eine Funktionsreferenz umgewandelt werden wobei der State zu dem Objekt hinzugefügt wird:

Code: Alles auswählen

type
  TMyNestedProcPointer = reference to procedure(Arg: Integer);
  TMyNestedFuncPointer = reference to function(Arg: Integer): Integer;

Die 3 basis funktionspointer (raw, method und nested) sind jeweils basisobjekte, im raw funktionspointer sind im Grunde Pointer und method und Nested sind im grunde ein Record mit 2 pointern.
Funktionsreferenzen erstellen eine instanz einer eigenen Klasse die auf dem Heap liegt, damit ist mit denen immer eine Memory Allokation verbunden und sie sind damit deutlich resourcen aufwendiger. Dafür vereinheitlichen sie alle drei konzepte und durch den State Capture als Closure bleibt der State auch über das lebensende der erstellenden Funktion erhalten.


PS: Anonymous Functions sind übrigens einfach nur nested procedures (wenn sie auf state zugreifen, sonst sogar raw), und sind daher entweder als nested(raw) funktionspointer oder funktionsreferenz darstellbar

[Mathias]

Code: Alles auswählen

type
  TMyProcPointer = procedure(Arg: Integer);
  TMyFuncPointer = function(Arg: Integer): Integer);

Dies ist die klassischste Variante, welche auch sehr viel bei C-Bindungen verwendet werden.
Dabei ist es wichtig, das man noch ein cdecl hinzufügt.
Das sieht dann so aus:

Code: Alles auswählen

type
  TMyProcPointer = procedure(Arg: Integer); cdecl;
  TMyFuncPointer = function(Arg: Integer): Integer); cdecl;

[PascalDragon]

Ungetestet

Code: Alles auswählen

sf := TmyFeld.Create(self, ..., Pointer(@setFilter));  //Harter Cast

Damit brauchst du aber wieder einen Cast zurück im Constructor, glaub ich zumindest

Das ist falsch. Wie Warf erklärt besteht ein Methodenzeiger aus einem Zeiger auf den jeweiligen Code und auf den Wert von Self. Wenn du nur einen Pointer übergibst, dann verliert sich einer von beiden und das wird letztlich zu Abstürzen fühern. Nimm also zum Übergeben von Methodenzeigern (oder Funktionszeigern allgemein) immer den passenden Typen, den nur dann ist sichergestellt, dass alles nötige korrekt übergeben wird.