C++ Java Handler equivilent - c++

Question

I'm coming from a Java/C# background and am new to C++. I am writing a library and am trying to accomplish the same functionality as a Handler does in Java. My scenario is as follows:
I am building a WinRT library that a user will put into his mobile/desktop app. At some point, after some network communication happens, a piece of data will come in that I want to pass along to the user. In Java, I declare a public static Handler (but do not initialize it) that the user can initialize. When the data comes in, I send a message through that Handler, and the end user's declaration within their app gets called, receiving the message and grabbing the data from it.
I can't seem to find a way to do the same in C++. I have looked at all kinds of posts/documentation on delegates/function pointers, utilizing the mighty Google with keywords like "callback", "handler", and "delegate". I think I have a half-formed understanding that it work differently in C++, but nothing is bearing fruit.
Could anyone kindly point me in the right direction?

Answer 1

Pretty much the same as you'd do it in Java. In your library, define a pure virtual class (more-or-less analogous with Java interface) of the handler.
class somethinghandler
{
public:
virtual void somethinghappened(<stuff that happened>) = 0;
}
And define and implement a class to watch for the event and call the function defined in the handler. This class contains a pointer, or list of pointers, objects installed by the client and methods to add and remove clients. If possible, don't use pointers at all let something do all of the containing. Life is cleaner that way. If you can't, guard the pointers with shared_ptr so that they cannot easily be destroyed before they are removed from the watcher.
class somethingwatcher
{
public:
bool addClient(std::shared_ptr<somethinghandler> clientToAdd);
bool removeClient(std::shared_ptr<somethinghandler> clientToRemove);
void applogic();
private:
std::shared_ptr<somethinghandler> client;
// or std::vector<std::shared_ptr<somethinghandler>> clients;
}
Finally, somewhere in somethingwatcher's application logic you detect something happened and call the client.
void somethingwatcher::applogic()
{
// do stuff
if(<something happened>)
{
// or iterate through the list of clients and doing for each:
if (client != nullptr)
{
client->somethinghappened(<stuff that happened>);
}
}
}
The library doesn't need to know anything about the client other than it exists and implements the somethinghappened function defined in somethinghandler. So long as you have a valid pointer, magic happens. Well, not really but this isn't the right place to go into how that "magic" works.
Outside the library in Client Land...
The client code defines and implements a class that implements somethinghandler to receive calls to somethinghappened.
class somethingclient: public somethinghandler
{
public:
void somethinghappened(<stuff that happened>);
\\ handles something happening.
}
Assuming the client code has instantiated a somethingwatcher named watcher, then an initialization routine creates and adds a somethingclient to watcher.
std::shared_ptr<somethinghandler> handler = std::make_shared<somethingclient>(constructor arguments);
watcher.addClient(handler);