Динамически создавать общий указатель функции из указателя метода, выводя возвращаемое значение и параметры.

Мне не совсем понятно, какой уровень универсальности вы ищете, но, возможно, это поможет вам начать:

typedef std::function<DWORD()> ThreadFuncT;

DWORD WINAPI RunThreadFunction(void* data)
{
    std::unique_ptr<ThreadFuncT> tf(static_cast<ThreadFuncT*>(data));
    return (*tf)();
}

template<typename F>
ThreadFuncT* MakeThreadFunction(F&& f)
{
    return new ThreadFuncT(std::forward<F>(f));
}

// ...

auto myClass = std::make_shared<SomeClass>(/* ... */);
CreateThread(
    nullptr,
    0,
    RunThreadFunction,
    MakeThreadFunction([=]() { return myClass->ThreadFunction(nullptr); }),
    0,
    nullptr
);

Обратите внимание, что поскольку myClass является std::shared_ptr<> и захватывается по значению, базовое время жизни SomeClass завершится должным образом, даже если myClass выйдет за пределы области действия до завершения выполнения потока (до тех пор, пока RunThreadFunction в конечном итоге вызывается).

EDIT: Вот еще один подход (непроверенный, могут быть синтаксические ошибки):

template<typename R>
R WINAPI RunThreadFunction(void* data)
{
    typedef std::function<R()> ThreadFuncT;
    std::unique_ptr<ThreadFuncT> tf(static_cast<ThreadFuncT*>(data));
    return (*tf)();
}

template<typename F>
auto MakeThreadFunction(F&& f) -> std::function<decltype(f())()>*
{
    return new std::function<decltype(f())()>(std::forward<F>(f));
}

// ...

auto myClass = std::make_shared<SomeClass>(/* ... */);
auto f = [=]() { return myClass->ThreadFunction(nullptr); };
CreateThread(
    nullptr,
    0,
    RunThreadFunction<decltype(f())>,
    MakeThreadFunction(std::move(f)),
    0,
    nullptr
);

Посмотрите, хотите ли вы этого. Вам все еще нужно указать тип возвращаемого значения, но он прекрасно (на мой взгляд) указан как параметр шаблона для struct, который содержит static функции-оболочки. Вы все еще можете улучшить его, если вам нужна более высокая степень гибкости для TTst. Я не уверен, как вы хотите определить вызываемые функции-члены, поэтому я сохранил их подпись как callback.

#include <iostream>

typedef int (*TFoo00)( void * );
typedef bool (*TFoo01)( int, void * );

void Bar00( TFoo00 fnc, void * ud )
{
 std::cout << "Bar00" << std::endl;
 fnc( ud );
}
void Bar01( TFoo01 fnc, void * ud )
{
 std::cout << "Bar01 " << std::endl;

 fnc( -1, ud );
}

class TTst;

template< typename PResult >
struct TWrap
{

  static PResult Call( void * ud )
  {
   std::cout << "TWrap::Call( P00 )" << std::endl;
   return ( static_cast< TTst * > ( ud )->Foo00() );
  }
  template< typename P00 >
  static PResult Call( P00 u00, void * ud )
  {
   std::cout << "TTst::Call( P00, P01 )" << std::endl;
   return ( static_cast< TTst * > ( ud )->Foo01( u00 ) );
  }
};

class TTst
{
 public:
  int Foo00( void )
  {
   std::cout << "TTst::Foo00" << std::endl;
   return ( 0 );
  }
  bool Foo01( int u00 )
  {
   std::cout << "TTst::Foo01 : "  << u00 << std::endl;
   return ( u00 != 0 );
  }

  void Do( void )
  {
   Bar00( TWrap< int >::Call, this );
   Bar01( TWrap< bool >::Call, this );
  }

};

int main( void )
{
 TTst lT;

 lT.Do();

 return ( 0 );
}

РЕДАКТИРОВАТЬ: изменены аргументы для Bar01 - я не заметил, что он принимает 2 аргумента как Bar00... Просто чтобы уточнить, вам нужно определить одну шаблонную функцию Call для всех Callback, которые имеют одинаковое количество аргументов.

EDIT: Это не совсем то, что нужно OP. ОП нуждается в общей версии этого.

Почему бы не использовать std::function полностью?

Это будет выглядеть как

std::function<void(void)> myFunc = std::bind(&Class::memberFunc,&classInstance);
CreateThread(NULL,0,runStdFunction, new std::function<void(void)>(myFunc),0,NULL);

runStdFunction будет таким же простым, как пирог

Я использую typedef std::function<void(void)> voidFunction для простоты.

void runStdFunction(void *data)
{
   std::unqiue_ptr<voidFunction> func (static_cast<voidFunction*>(data));
   (*func)();
}

Идея проста, все, что вы делаете, это передаете std::functions, а затем вызываете их. Оставьте все преобразования в/из функций-членов/и т.д. в std::bind.

Конечно, ваш возвращаемый тип не пуст, но это незначительная деталь.