Native C++11 Event - Event with nothing bound throws error - c++

Question

I have an event handler as such,
__event void MouseMoved(int MousePosX, int MousePosY);
and it is raised via
__raise MouseMoved(MousePosX, MousePosY);
This works perfectly fine after using __hook to add a function to the event; however, if I raise the even though any functions bound to the event I get a runtime error. Is there a way to check for the event being empty before raising it?

Answer 1

C++ '11 does not have native events. Neither does C++ '14.
What this looks like to me is a feature specific to Microsoft Visual C++ - maybe Microsoft's Unified Event Model? If that's the case, raising an event that has no subscribers should not cause an error according to their docs:
To fire an event, simply call the method declared as an event in the event source class. If handlers have been hooked to the event, the handlers will be called.
On the other hand, .NET requires you to check events for being null before raising them and those keywords you're using also work in a managed C++ project, so if you created a managed application, it may very well be that you need to do something like
if(MouseMoved != nullptr) {
__raise MouseMoved(MousePosX, MousePosY);
}
If you want to write portable C++ that works on other compilers and/or platforms, I can recommend libsigc++ or JL Signal.

Answer 2

I opted for just defining my own event object which holds a list of function pointers that can be invoked in order. If functions much the same as events and eventhandlers in C#.
struct EventArg
{
public:
EventArg(){}
~EventArg(){}
static EventArg Empty()
{
EventArg empty;
return empty;
}
};
template <typename T>
class EventHandler
{
public:
EventHandler(void(T::*functionHandle)(void*, EventArg), T* receiver)
{
this->functionHandle = functionHandle;
this->receiver = receiver;
}
virtual void Call(void* sender, EventArg e)
{
(receiver->*functionHandle)(sender, e);
}
private:
void (T::*functionHandle)(void*, EventArg);
T* receiver;
};
class Event
{
private:
std::vector<EventHandlerBase*> EventHandlers;
public:
void Raise(void* sender, EventArgT e)
{
for (auto item = EventHandlers.begin(); item != EventHandlers.end(); item++)
(*item)->Call(sender, e);
}
void Add(EventHandler* functionHandle)
{
EventHandlers.push_back(functionHandle);
}
void Remove(EventHandler* functionHandle)
{
for (auto item = EventHandlers.begin(); item != EventHandlers.end(); item++)
{
if ((*item) == functionHandle)
{
EventHandlers.erase(item);
return;
}
}
}
}