Question

I would love create javascript’s setTimeout and setInterval like functionality for c++ (without boost). What I would like to achieve: A base class which could call its sub-classed member variables at a repeated or after a single delay.

I have an update function already and time elapsed functionality. I have also found how to pass a member function pointer to the base class and trigger that function using:

class BaseClass {
public:
     template <class object>
     void triggerNow(object *obj, void (object::*func)()) {
          ((obj)->*(func))();
     }

} 

class SubClass : public BaseClass {
public:
    void update() {
         triggerNow(this, &SubClass::worked)
    }
    void worked() {
         cout << "worked!";
    }
}

The problem I currently face is how to store object *obj and void (object::*func)() in a vector (or other container). I am only just figuring out templates…

How can I store the two templated parameters of triggerNow in a vector? Once I can figure this out, I can create my setTimeout and setInterval!

Answer 1

In order to store object* and object::*func in a vector you can do it like this:

struct Callable
{
  virtual ~Callable () {};
  virtual void operator()() = 0;
};

template <class Object>
struct TemplateCallable : public Callable
{
  typedef void (Object::*MemberFunction)();

  TemplateCallable(Object* obj, MemberFunction mem_fun)
     : _object(obj),
       _mem_fun(mem_fun)
  {}

  void operator() ()
  {
    _object->*_mem_fun();
  }

  Object* _obj;
  MemberFunction _mem_fun;
};

Now you can store them as Callable’s in a std::vector, because the templated version is derived from Callable. If you store pointers in a std::vector<> though you need to remember to delete them at some point.

So will get something like this:

class TimerSomething
{
   template <class Object>
   void registerCallback (Object* obj, void (Object::*MemFun)())
   {
     _callbacks.push_back(new TemplatedCallback<Object>(obj, mem_fun));
   }

   void triggerAll ()
   {
     for (std::vector<Callable*>::iterator iter = _callbacks.begin();
          iter != _callbacks.end(); ++iter)
     {
       (**iter)();
     }
   }

   std::vector<Callable*> _callbacks;
};