Class serving data via callbacks - c++

Question

I have recently returned to Visual C++ after a while programming in C where callbacks are much easier.
I have a singleton class which controls 0..* connected devices.
My idea is to create a function in this class which will iterate over the set of
connected devices and publish it via a callback to whatever might require it.
e.g.
Singleton class
typedef void (CALLBACK * PortListCallback_t)(ptrConstCComPortInfo_t);
.
.
.
void CCommsMgr::listPorts(PortListCallback_t cb)
{
PortInfoSetConstIter_t i;
for (i = m_setPorts.begin(); i != m_setPorts.end(); i++)
{
cb(*i);
}
}
In the first instance the consumer is an MFC dialog class which works fine if it's callback is static. However in order to access member data/functions of the dialog class I would need to pass 'this' to the singleton class and have it reflected back.
e.g.
Singleton class
typedef void (CALLBACK * PortListCallback_t)(void *, ptrConstCComPortInfo_t);
.
.
.
void CCommsMgr::listPorts(void *pObj, PortListCallback_t cb)
{
PortInfoSetConstIter_t i;
for (i = m_setPorts.begin(); i != m_setPorts.end(); i++)
{
cb(pObj, *i);
}
}
Dialog Class
static void CALLBACK getPorts(void *obj, ptrConstCComPortInfo_t port);
.
.
.
void CALLBACK CMFC_iTFTPDlg::getPorts(void *obj, ptrConstCComPortInfo_t port)
{
CMFC_iTFTPDlg *pThis = (CMFC_iTFTPDlg*)obj;
// do something with it
}
My question - Is there a better way of doing this? Static functions feel like a kludge and I do not want the Singleton class to be constrained by how it might be used.
If I remove the static on getPorts it will not compile. To repeat myself the Singleton class should have no knowledge of it's consumer.

Answer 1

With help from the excellent hints from WhozCraig, this is what I came up with:
#include <functional> // std::function, std::bind, std::placeholders
#include <iostream>
#include <vector>
class ConstCComPortInfo {};
using ptrConstCComPortInfo_t = ConstCComPortInfo*;
using callback_t = void(void*, ptrConstCComPortInfo_t);
using function_t = std::function<callback_t>;
// an example class with a member function to call
class foo {
public:
foo(const std::string& name) : instance_name(name) {}
void bar(void* something, ptrConstCComPortInfo_t c) {
std::cout << "foo::bar(" << instance_name << ") called\n"
"void* = " << something << "\n"
"ptrConstCComPortInfo_t = " << c << "\n";
}
private:
std::string instance_name;
};
// and a free function to call
void free_func(void* something, ptrConstCComPortInfo_t c) {
std::cout << "free_func_called\n"
"void* = " << something << "\n"
"ptrConstCComPortInfo_t = " << c << "\n";
}
int main() {
// some instances of the class
foo via_bind("called_via_bind");
foo via_lambda("called_via_lambda");
ptrConstCComPortInfo_t bork = nullptr; // dummy value
// a vector of callback subscribers
std::vector<function_t> subscribers{
&free_func,
std::bind(&foo::bar, &via_bind, std::placeholders::_1, std::placeholders::_2),
[&via_lambda](void* p, ptrConstCComPortInfo_t c) { via_lambda.bar(p, c); }
};
// perform callbacks
for(auto& cb : subscribers) {
cb(nullptr, bork);
}
}
Output:
free_func_called
void* = 0
ptrConstCComPortInfo_t = 0
foo::bar(called_via_bind) called
void* = 0
ptrConstCComPortInfo_t = 0
foo::bar(called_via_lambda) called
void* = 0
ptrConstCComPortInfo_t = 0