Здравствуйте, k732, Вы писали:

Что-нибудь навроде

class WaitableObject
{
public:
  virtual void Wait(unsigned period) = 0;

protected:
  WaitableObject(){}
  virtual ~WaitableObject(){}

private:
  WaitableObject(const WaitableObject&);
  WaitableObject& operator =(const WaitableObject&);
};

typedef void* ThreadFuncArgType;
typedef void (*ThreadFuncType)(void*);

class Thread: public WaitableObject
{
public:
  virtual ~Thread();

  virtual Thread* Execute() = 0;
  virtual Thread* Execute(ThreadFuncType fn, ThreadFuncArgType arg) = 0;

  static Thread* CreateThread();
  static Thread* CreateThread(ThreadFuncType fn, ThreadFuncArgType arg);
  template <class T, void (T::*fn)()>
    static Thread* CreateThread(T* obj);

protected:
  Thread();

private:
  Thread(const Thread&);
  Thread& operator =(const Thread&);
};

//////////////////////////////////////////////////////////////////////////
// helpers

template <class T, void (T::*fn)()>
  void ThreadFuncImpl(void* arg)
{
  T* instance = reinterpret_cast<T*>(arg);
  (instance->*fn)();
}

#define CREATETHREAD(klass, method, object)\
Thread::CreateThread(ThreadFuncImpl<klass, klass::method>, object)

#define CREATETHREAD_EXECUTE(klass, object, method)\
CREATETHREAD(klass, method, object)->Execute()

#define CREATETHREAD_EXECUTE_WAIT(klass, object, method)\
CREATETHREAD_EXECUTE(klass, method, object)->Wait()

Имплементация очевидная.

Используется тоже понятно как:

void fn()
{
  class A
  {
  public:
    void Do(){}
  };

  CREATETHREAD_EXECUTE_WAIT(A, Do, new A); 
}