Using async with a polymorphic member function - c++

Question

Trying to create an asyncronous Observer pattern is causing a compiler error C3867, which I am clueless how to resolve it. The sample code snippet is as follows
class Subject;
class Observer
{
public:
virtual void notify(Subject* s) = 0;
virtual ~Observer() {};
};
class Subject
{
std::map<std::string, Observer *> observers;
protected:
void notify_observers()
{
std::map<std::string, Observer *>::iterator iter;
for (iter = observers.begin(); iter != observers.end(); ++iter) {
void (Observer::*notify)(Subject *) = iter->second->notify;
std::async(std::launch::async, notify, this);
}
}
public:
virtual ~Subject() {};
void observer(std::string id, Observer* o)
{
observers[id] = o;
}
};
template<typename Iter, typename type>
class Sort : public Observer {
public:
virtual void notify(Subject* s)
{
TestSort<Iter> *a;
a = dynamic_cast<TestSort<Iter> *>(s);
std::vector<type> temp(a->beg(), a->end());
sort(temp->beg(), temp->end());
}
};
template<typename Iter, typename type>
class InsertionSort : public Sort<Iter, type>
{
void sort(Iter beg, Iter end) {
for (Iter i = beg; i != end; ++i)
std::rotate(std::upper_bound(beg, i, *i), i, i+1);
}
};
int main ()
{
std::vector<double> data(100);
std::generate(data.begin(), data.end(), [](){return rand() % 500;} );
auto ts = TestSort<std::vector<double>::iterator >(data.begin(), data.end());
auto is = new InsertionSort<std::vector<double>::iterator, double >();
//.................
ts.observer("InsertionSort", is);
//.........................
ts.Triggerd();
return 0;
}
Though I understand the error
error C3867: 'Observer::notify': function call missing argument list; use '&Observer::notify' to create a pointer to member
Yet in this context I cannot figure out, how to resolve it.
In this context, if notify would had been a simply addreesable member function, instead of
void (Observer::*notify)(Subject *) = iter->second->notify;
I could have simply write
void (Observer::*notify)(Subject *) = &Observer::notify;
But notify is a polymorphic function and I cannot address the right function during compile time.
Please suggest how should I process

Answer 1

You don't need to figure out the right function during compile time, just as you don't have to figure it out for regular virtual function call. Just use &Observer::notify. The right function is selected at the time of call, not at the time of taking its address.

Answer 2

Change:
void (Observer::*notify)(Subject *) = iter->second->notify;
std::async(std::launch::async, notify, this);
To:
void (Observer::*notify)(Subject *) = &Observer::notify;
std::async(std::launch::async, std::mem_fun(notify), iter->second, this);
When you call a method, you need both the pointer-to-instance and arguments. The standard syntax is rettype retval = instance->method(arg);, but std::mem_fun will return a functor you can use like rettype retval = std::mem_fun(&InstanceType::method)(instance, arg); -- it makes the implicit this pointer passed to a member function explicit.
From a pointer to a virtual method, plus an object pointer, std::mem_fun can figure out which instance of the virtual method you should call.
A similar thing can be done with a bind or a lambda. Here is a roughly equivalent call using lambda syntax:
Observer* observer = iter->second;
std::async(std::launch::async, [observer,this]() { observer->notify(this); } );
See the comment below: you don't have to use std::mem_fun, async will do it for you. You do have to pass the instance pointer of the member function as the next argument still.