Registering and (more importantly) Unregistering with Message Server

Question

I've finally implemented an extendable message class and messageServer class. The message class dynamically assigns a unique static ID to each derived message type (ex. ObjectCreatedMessage might be assigned id = 1). The actual message data is a member of the derived class.

Messages can be pushed to MessageServer class by upcasting to MessageBase*.

Systems (or anything) can subscribe to Message Server by passing a std::function to:

typedef std::function<void(MessageBase*)> Callback;
void registerCallback(int messageType, Callback callback);    

When MessageServer is processing messages, it pops a message off the queue, checks the message type, then sends the message to each callback function registered to that type.

---

My Questions are:

1. Is this efficient?
2. How could I implement an "unregister" function? std::functions can't be compared by equality.
3. What is a smart way to handle the callback failing? (perhaps the registered object went out of scope so the function pointer is undefined)

Answer 1

Using callbacks can be one way to decouple parts of a program. They're often used in GUI interaction because this interaction is generally sporadic and not something that happens excessively. So the caveats and downsides to callbacks don't out weigh the benefits of them.

If you intend to use callbacks for event handling, be mindful that emitting function callbacks in tight loops could be detrimental to your instruction and data cache.

Lastly, don't over estimate the power of polling. Often it is far more efficient to have an event be raised and placed into a queue/buffer. At future points in your code, you poll to determine what events have been raised that are of interest. This approach may be easier to apply parallel processing constructs against than if you used an immediate callback concept.