A pthread_create wrapper to launch any callable object in another thread.

gistfile1.cpp

#include <pthread.h>                                                           
                                                                               
struct ThreadBase                                                              
{                                                                              
  virtual ~ThreadBase(){}                                                      
  virtual void* operator() () = 0;                                             
};                                                                             
                                                                               
template<typename CallableObject>                                              
struct ThreadTask : public ThreadBase                                          
{                                                                              
  CallableObject callable;                                                     
                                                                               
  ThreadTask(const CallableObject & c):callable(c){}                           
  virtual ~ThreadTask(){}                                                      
                                                                               
  virtual void* operator() ()                                                  
  {                                                                            
    return callable();                                                         
  }                                                                            
};                                                                             
                                                                               
void* threadStarter(void* data)                                                
{                                                                              
  ThreadBase * helper = reinterpret_cast<ThreadBase*>(data);                   
  return (*helper)();                                                          
}                                                                              
                                                                               
template<typename CallableObject>                                              
int better_pthread_create(CallableObject o, pthread_t &threadObj)              
{                                                                              
  ThreadBase * th = new ThreadTask<CallableObject>(o);                         
                                                                               
  return pthread_create(&threadObj, NULL, threadStarter,                       
      reinterpret_cast<void*>(th));                                            
}