I am learning C++ and have been trying to create an event system for use in a small game. This will be the mechanism by which game entities communicate. I would be eternally grateful if someone with experience could critique my code. Running through it myself, I'm a little concerned about the use of Runtime Type Information (RTTI). I know that this is discouraged but I can't find any alternative to providing some basic type safety.class EventDispatcher{public:    /**     * Callback function type for event handling.     */    template<typename EventType>    struct Callback    {        /**         * Constructor.         */        Callback(boost::function<void(const EventType& event)> callback) :        handler(callback)        {            // Nothing to do.        }        /**         * Callback function.         */        boost::function<void(const EventType& event)> handler;    };    /**     * Constructor.     */    EventDispatcher();    /**     * Destructor.     */    ~EventDispatcher();    /**     * Subscribe to receive events.     *     * @param callback Event handler callback.     */    template <typename EventType>    void Subscribe(Callback<EventType> callback)    {        GetSpecificDispatcher<EventType>()->Subscribe(callback);    }    /**     * Immediately broadcast an event to subscribers.     *     * @param args... Event constructor arguments.     */    template <typename EventType, typename... Arguments>    void Broadcast(const Arguments... args)    {        GetSpecificDispatcher<EventType>()->Broadcast(EventType(args...));    }    /**     * Queue an event to be broadcast to subscribers on the next Update     * call.     *     * @param args... Event constructor arguments.     */    template <typename EventType, typename... Arguments>    void Enqueue(const Arguments... args)    {        GetSpecificDispatcher<EventType>()->Enqueue(EventType(args...));    }    /**     * Broadcasts all events in the queue to subscribers.     */    void Update()    {        for (auto iter = dispatchers.begin(); iter != dispatchers.end(); ++iter)        {            iter->second->Update();        }    }protected:    /**     * Event specific dispatcher interface.     */    class ISpecificDispatcher    {    public:        virtual void Update() = 0;    };    /**     * Event specific dispatcher.     */    template<typename EventType>    class SpecificDispatcher : public ISpecificDispatcher    {    public:        /**         * Subscribe to receive events.         *         * @param callback Event handler callback.         */        void Subscribe(Callback<EventType> callback)        {            callbacks.push_back(callback);        }        /**         * Immediately broadcast an event to subscribers.         *         * @param args... Event constructor arguments.         */        template <typename... Arguments>        void Broadcast(const Arguments... args)        {            EventType event(args...);            for (const Callback<EventType>& callback : callbacks)            {                callback.handler(event);            }        }        /**         * Queue an event to be broadcast to subscribers on the next Update         * call.         *         * @param args... Event constructor arguments.         */        template <typename... Arguments>        void Enqueue(const Arguments... args)        {            eventQueue.push(EventType(args...));        }        /**         * Broadcasts all events in the queue to subscribers.         */        virtual void Update()        {            while (!eventQueue.empty())            {                const EventType& event = eventQueue.front();                for (const Callback<EventType>& callback : callbacks)                {                    callback.handler(event);                }                eventQueue.pop();            }        }    private:        /**         * Queued events.         */        std::queue<EventType> eventQueue;        /**         * Event callback handlers.         */        std::vector<Callback<EventType>> callbacks;    };    /**     * Returns a pointer to the specific dispatcher for the event type.     * A specific dispatcher is first created if one does not exist.     */    template<typename EventType>    boost::shared_ptr<SpecificDispatcher<EventType>> GetSpecificDispatcher()    {        auto iter = dispatchers.find(typeid(EventType).name());        if (iter == dispatchers.end())        {            // A specific dispatcher was not found.            // We better create one!            boost::shared_ptr<SpecificDispatcher<EventType>> specificDispatcher(new SpecificDispatcher<EventType>());            dispatchers[typeid(EventType).name()] = specificDispatcher;            return specificDispatcher;        }        else        {            return boost::static_pointer_cast<SpecificDispatcher<EventType>>(iter->second);        }    }private:    /**     * Event specific dispatchers.     */    std::map<std::string, boost::shared_ptr<ISpecificDispatcher>> dispatchers;};
Event system using callback functions in C++
c++;c++11;event handling;boost;type safety