Printable View
I've got some code which fires multiple events and I'm trying to put it into a reusable class. I'm wondering what is considered the best method to make events available from a C++ class. Plain C style callback functions? Some sort of class based system (overridden functions in a derived class, for example)? Thanks.
Another possible solution is a queue similiar to a message queue in windows. Essentially its either on the server (send) side or client (receiver) side.
Kuphryn
Most of us actually avoid events like the plague due to hard to catch race conditions caused by the next to useless PulseEvent. Semaphores can be used instead but are slower due to kernel transitions.
This is an interesting idea. However, the program would already be running a Windows message loop, so I'm not sure how practical a secondary message pump would be. Window messages would be an option, but there may be no window. I'm more interested in a callback solution. I'm unsure what the preferred callback pattern is in C++. Should the callbacks be standalone C style functions, or part of a class? If I use a class, is it possible to make it so that not all of the event functions need to be implemented?Quote:
Another possible solution is a queue similiar to a message queue in windows. Essentially its either on the server (send) side or client (receiver) side.
Sorry, my post wasn't entirely clear. I was not talking about Windows event objects, rather triggered events. For example, one event is the screen saver starting, another is the network cable unplugged. I'm wondering how, once received by my class, these events would best be dispatched to the user code.Quote:
Most of us actually avoid events like the plague due to hard to catch race conditions caused by the next to useless PulseEvent. Semaphores can be used instead but are slower due to kernel transitions.
It's quite interesting that you ask about this because I'm working on exactly such a thing right now. The way I've implementing it is within a wrapper interface to the API. (Btw, shouldn't this be on the Windows board?) There are two points at which you can intercept the messages of which you're speaking, but it should be obvious that they would not be possible in an MFC app. First, in my message loop I call the primary window's process_message() function which acts similar to PreTranslateMessage(). Now, this is probably not going to work for you because it assumes and depends too many variables. The second method would be to have an event-handler installation procedure that maps specific messages to a [member] function of your class. Then in your WindowProcedure the first thing you can do is check the map to see if the msg is mapped to a function. If it is, invoke it (and check the return value to determine if the message should be processed any further). Otherwise, just DefWindowProc() as usual.
Here's some pseudocode in an effort to provide you with a better understanding of my suggestion:It's not going to be as simple as I've written it here, but it should get some idea juices flowing.Code:install_event_handler(msg_you_want, function_pointer_to_your_handler);// call to the event handler installation function
// now here's what you can do in your WindowProc
iterator itr = the_message_map.find(msg);
if (itr != the_map.end())
itr->second(wparam, lparam);
Whats going to be calling your callbacks? What exactly are you trying to do? Would the command pattern with generalized functors be any help. Hard to tell without more info.
I'm rather fond of the observer pattern myself. Since I'm too lazy at the moment to write much, here is a decent looking link.
You can of course, modify this. Perhaps, have subject adapters and listener adapters for your objects, and run all messages through a central observer-manager of sorts.
Command and Observer patterns typically use object interfaces and polymorphism as the "callback mechanism". This is a common method of generalizing a callback with a known interface.
Another way of generalizing a callback with a known interface is to use a functor object as a templated type. This method can also utilize polymorphism but isn't needed. For example, the STL uses this method when ever a predicate of some sort (pun intended) is needed.
boost::function can be a usefull tool when designing a framework that involves callbacks.
gg
If you have a lot of C++ events, you could try using a slot library. The boost library has one and so does the gnome libraries. Otherwise, I'd just go with what the other posters said.Quote:
I've got some code which fires multiple events and I'm trying to put it into a reusable class. I'm wondering what is considered the best method to make events available from a C++ class. Plain C style callback functions? Some sort of class based system (overridden functions in a derived class, for example)? Thanks.
OK, I've been madly reading up on event maps (thanks LuckY), the command pattern (thanks Stoned_Coder & Codeplug), the observer pattern (thanks Zach L.), delegates (which seem very similar to the signal/slot pattern) and the signal/slot pattern (also good PDF writeup) (thanks okinrus).
While I think all these solutions are workable (although the observer pattern would seem to be best suited for situations where the subject maintains state that can be retrieved by the observer), the signal/slot pattern seems the neatest. I find it a little ironic, that given all the power of the C++, we get back to nearly C style function callbacks (albeit callbacks that can be attached to a class and have lifetime management).
However, in the end, I went with overridden methods in a class derived from the source sink. This is not 100% ideal, but means no extra code to handle event dispatching. The user code looks like this:
The main drawback with this solution is that CSensSink, being a COM object, has internal lifetime management (delete this is called when the ref count reaches zero). This means that the derived event sink cannot be created on the stack or explicitly deleted. As I said, not 100% ideal...Code:class MySensSink : public CSensSink
{
STDMETHODIMP StartScreenSaver(BSTR bstrUserName)
{
puts("Start Overridden");
return NOERROR;
}
STDMETHODIMP StopScreenSaver(BSTR bstrUserName)
{
puts("Stop Overridden");
return NOERROR;
}
/* Other overridden methods here. */
};
int main(void)
{
CSensSystem sens;
MySensSink* sink = new MySensSink;
CoInitialize(NULL);
sens.HookEvent(SENS_StartScreenSaver, sink);
sens.HookEvent(SENS_StopScreenSaver, sink);
...
}
Thanks everybody for the help, I've learnt a lot. I'll post the complete code when it's finished (in the Windows forum).
Hey,
I started writing some code in c++ where I raise signals.
Does anyone know if it's possible to "catch" signals (like events) in vb.net?
(i'm wrapping my c++ function, so I wanted to do something like raising events, without all the complicated code; hence signals; but now I dont know how to handle the event/signal in vb.net)
If raising signals cannot be handled in vb.net, how would I raise something like events in c++ and have corresponding handlers in vb.net? (Does anyone know the syntax?) :)
THANKS!! :D
anyone?? :(
Welcome to the boards.
Please read the Forum Guidelines, paying special attention to #5.
A listing of the different board topics can be found here: http://cboard.cprogramming.com/index.php
As you can see, there is no "VB.NET" board. The C# board may be able to help you in generic ".NET" terms.
gg
sorry i didnt know. :(