C++Builder: Ereignisbehandlung zur Laufzeit zuweisen

[Rainer R. (Firma: Reusch Elektronik) (reusch)]

Hallo C++Builder-Fachleute!
In einem C++Builder-6-Projekt (ich weiß, der ist steinalt, die 
Fragestellung gilt aber auch für RAD-Studio XE) verwende ich eine 
nichtvisuelle Komponente (nennen wir sie "TSerial"). Sie wird zur 
Laufzeit erzeugt:

Serial = new TSerial(NULL);
Serial->Name = "ABC";

Die Komponente kennt das Ereignis "OnEventChar". Diesem Ereignis soll 
eine Funktion zugewiesen werden. Ist die Ereignisbehandlungsroutine 
innerhalb eines Formulars deklariert, etwa in der Art

void __fastcall TForm1::EventChar(TObject *Sender)
{
  ...
}

ist auch die Zuweisung kein Problem:

Serial->OnEventChar = EventChar;

***

In meinem Problemfall verwende ich die Komponente jedoch nicht in einem 
Formular sondern in einer DLL sozusagen "standalone", d.h. die Variable 
"Serial" ist eine globale Variable in der DLL. Da es kein Formular gibt, 
ist auch die Ereignisbehandlungsroutine als normale Funktion deklariert:

void __fastcall EventChar(TObject *Sender)
{
  ...
}

Dadurch funktioniert die Zuweisung einer Ereignisbehandlungsroutine, wie 
oben gezeigt, nicht mehr. Der Compiler wirft die Fehlermeldung

[C++ Fehler] Unit_Serial.cpp(109): E2034 Konvertierung von 'void 
(_fastcall *)(TObject *)' nach 'void (_fastcall * (_closure )(TObject 
*))(TObject *)' nicht möglich

aus. Der Typ der Ereignisbehandlungsroutine passt also nicht mehr ganz. 
Ich habe schon einiges rumprobiert und nach passenden Lösungen im Netz 
gesucht -- erfolglos. Vielleicht hat in diesem Forum jemand die richtige 
Lösung zur Hand, wie die Ereignisbehandlungsroutine in diesem Fall 
deklariert werden muss oder wie der Typecast bei der Zuweisung 
auszusehen hat.

Übrigens: Unter Pascal (Delphi) ist die Lösung sehr einfach. Der 
Funktionsdeklaration der Ereignisbehandlungsroutine wird einfach "of 
object" dran gehängt. Beim C++Builder wird das aber anders sein!

Für eure produktiven Lösungsvorschläge schon mal vielen Dank!

[Jim M. (turboj)]

Rainer R. schrieb:
> Übrigens: Unter Pascal (Delphi) ist die Lösung sehr einfach. Der
> Funktionsdeklaration der Ereignisbehandlungsroutine wird einfach "of
> object" dran gehängt. Beim C++Builder wird das aber anders sein!

Naja nicht wirklich. Eine Function "of object" besteht aus 2 Dingen: 
Einer Objektrefrenz und dem eigentlichen Methodenzeiger. Das kann man 
nicht auf einen einfachen Funktionszeiger casten.

Daher deine längliche Fehlermeldung, die Dir IMO aber auch eine mögliche 
Typdeklaration aufzeigt.

[Oliver R. (superberti)]

Der C++-Builder benutzt für seine Events sogenannte Closures. Das sind 
Funktionspointer mit implizitem this-Pointer, um auch nicht-statische 
Objektmethoden aufrufen zu können.
Bei Microsoft heißt das im Allgemeinen Delegate.
Du brauchst für die Zuweisung des Events nicht unbedingt ein Form, 
sondern vielmehr ein lebendes Objekt, welches z.B. folgende Methode 
implementiert:

void __fastcall MyObject::EventChar(TObject *Sender)
{
  ...
}

und dann später

...
MyObject meins;
Serial->OnEventChar = meins.EventChar;

Falls Du ansonsten keine Objekte hast, kannst Du ja aus Deinem 
Hilfsobjekt "MyObject" die entsprechenden C-Funktionen oder was auch 
immer aufrufen.


Man kann auch eigene Closures deklarieren, wie z.B.

/// Event, wenn Aktionen für markierte Messungen ausgelöst werden
/// \param BrowserAction Gibt an, was mit der Selektion geschehen soll
/// \param Selection Indizes der ausgewählte Messungen (set)
typedef bool (__closure *TDBBrowserEvent)(const BrowserEventAction BrowserAction, const SelectionVec & Selection);

Dies deklariert beispielsweise eine Funktion, die einen bool 
zurückliefert und einen Enum sowie einen Vektor als Parameter erwartet.
In Deinem Programm kann man dann den Closure wie eine Variable 
verwenden:

TDBBrowserEvent MyBrowserEvent;

Gruß,
Oliver

[Rainer R. (Firma: Reusch Elektronik) (reusch)]

Hallo Oliver!
Vielen Dank für deine Ausführungen!
An ein "Hilfsobjekt" habe ich auch schon gedacht, als Notlösung, falls 
sich doch keine "saubere" Lösung auftut. Da es diese in Pascal (Delphi) 
ja gibt, sollte es diese auch unter C++ geben. Du hast das mit Deinem 
zweiten Ansatz ja auch angedeutet. Das spiegelt auch das wider, was 
meine Internet-Recherche ergeben hat.

Angepasst auf meinen Anwendungsfall schreibe ich also:

typedef void __fastcall (__closure *TMyEvent)(TObject *Sender);
TMyEvent MyEvent;
Serial->OnEventChar = MyEvent;

Bis dahin schluckt der Compiler auch alles. Doch wie deklariere ich nun 
die eigentliche Ereignisbehandlungsroutine?
(irgendwie stehe ich auf dem Schlauch)

[Oliver R. (superberti)]

Hi Rainer,

die Definition des Handlers habe ich in meinem Post ja schon 
hingeschrieben:

void __fastcall MyObject::MyEvent(TObject *Sender)
{
  ...
}

Im Header wäre dann die Deklaration

class MyObject
{
  ...
  void __fastcall MyEvent(TObject *Sender);
  ...
}

Du kannst also Deinem Event jede Member-Funktion eines beliebigen 
Objekts zuweisen, sofern sie den Rückgabewert void hat und ein TObject 
als Parameter erwartet.
Nochmal: Ein Closure ist IMMER ein Zeiger auf eine Memberfunktion eines 
Objekts. Das ist keine Notlösung, sondern genau so gewollt. Dies ist der 
Mechanismus, mit dem die VCL als Oberflächenframework arbeitet.


Gruß,
Oliver

[Rainer R. (Firma: Reusch Elektronik) (reusch)]

Hallo Oliver!
Nun ja, das ist die Lösung mit dem Hilfsobjekt! Aber gut, das ist jetzt 
zwar nicht so elegant, die Umsetzung ist aber auch nicht allzu 
aufwändig. Zusammengefasst sieht das in etwa so aus:

class TMyObject {
public:
  void __fastcall SerialEventChar(TObject *Sender);
  __fastcall TMyObject(void);
  __fastcall ~TMyObject(void);
};
TMyObject *MyObject;

__fastcall TMyObject::TMyObject(void)
{
  //
}

__fastcall TMyObject::~TMyObject(void)
{
  //
}

void __fastcall TMyObject::SerialEventChar(TObject *Sender)
{
  ...
}

MyObject = new TMyObject();
Serial->OnEventChar = MyObject->SerialEventChar;

Nochmals vielen Dank für Deine Hilfe!