Re: a really simple C++ abstraction around pthread_t...

I use the following technique in all of my C++ projects; here is the exam=

code with error checking omitted for brevity:
_________________________________________________________________
/* Simple Thread Object
______________________________________________________________*/
#include <pthread.h>

extern "C" void* thread_entry(void*);

class thread_base {
  pthread_t m_tid;
  friend void* thread_entry(void*);
  virtual void on_active() = 0;

public:
  virtual ~thread_base() = 0;

  void active_run() {
    pthread_create(&m_tid, NULL, thread_entry, this);
  }

  void active_join() {
    pthread_join(m_tid, NULL);
  }

};

thread_base::~thread_base() {}

void* thread_entry(void* state) {
  reinterpret_cast<thread_base*>(state)->on_active();
  return 0;

}

template<typename T>
struct active : public T {
  active() : T() {
    this->active_run();
  }

  ~active() {
    this->active_join();
  }

  template<typename T_p1>
  active(T_p1 p1) : T(p1) {
    this->active_run();
  }

  template<typename T_p1, typename T_p2>
  active(T_p1 p1, T_p2 p2) : T(p1, p2) {
    this->active_run();
  }

  // [and on and on for more params...]

};

/* Simple Usage Example
______________________________________________________________*/
#include <string>
#include <cstdio>

class worker : public thread_base {
  std::string const m_name;

  void on_active() {
    std::printf("(%p)->worker(%s)::on_thread_entry()\n",
      (void*)this, m_name.c_str());
  }

public:
  worker(std::string const& name)
    : m_name(name) {
    std::printf("(%p)->worker(%s)::my_thread()\n",
      (void*)this, m_name.c_str());
  }

  ~worker() {
    std::printf("(%p)->worker(%s)::~my_thread()\n",
     (void*)this, m_name.c_str());
  }

};

class another_worker : public thread_base {
  unsigned const m_id;
  std::string const m_name;

  void on_active() {
    std::printf("(%p)->my_thread(%u/%s)::on_thread_entry()\n",
      (void*)this, m_id, m_name.c_str());
  }

public:
  another_worker(unsigned const id, std::string const& name)
    : m_id(id), m_name(name) {
  }

};

int main(void) {
  {
    active<worker> workers[] = {
      "Chris",
      "John",
      "Jane",
      "Steve",
      "Richard",
      "Lisa"
    };

    active<another_worker> other_workers[] = {
      active<another_worker>(21, "Larry"),
      active<another_worker>(87, "Paul"),
      active<another_worker>(43, "Peter"),
      active<another_worker>(12, "Shelly"),
    };
  }

  std::puts("\n\n\n__________________\nhit <ENTER> to exit...");
  std::fflush(stdout);
  std::getchar();
  return 0;}

_________________________________________________________________

I personally like this technique better than Boost. I find it more straig=

forward and perhaps more object oriented, the RAII nature of the `active'
helper class does not hurt either. Also, I really do think its more
"efficient" than Boost in the way it creates threads because it does not
copy anything...

IMHO, the really nice thing about it would have to be the `active' helper
class. It allows me to run and join any object from the ctor/dtor that
exposes a common interface of (T::active_run/join). Also, it allows me to
pass a variable number of arguments to the object it wraps directly throu=

its ctor; this is fairly convenient indeed...

Any suggestions on how I can improve this construct?