Статический метод как точка входа в поток - как избавиться

#include <iostream>
#include <thread>
 
class some_class
{
   mutable std::thread t;
   int val = 100;
public:
   void foo(int n) const
   {
      for (int i = 0; i < n; ++i)
         std::cout << "Hello from foo. val = " << val << "\n";
   }
 
   void create_thread() const
   {
      t = std::thread(&some_class::foo, this, 5);
      t.join();
   }
};
 
int main()
{
   some_class sm;
   sm.create_thread();
 
   return 0;
}

class Figure
{
public:
  void MoveDown()
  {
    // ...
  }
 
  static void MoveDown(PVOID figure)
  {
    static_cast<Figure*>(figure)->MoveDown();
  }
};

...
class primer
public:
void funcmain(int i);
static DWORD WINAPI fun(PVOID object)
{
static_cast<primer*>object -> funcmain(что сюда передать и как);
...

class primer
{
public:
  void funcmain(int i);
};
 
struct ObjAndParam
{
  primer* obj;
  int param;
};
 
static void ThreadFun(void* data)
{
  ObjAndParam* objAndParam = static_cast<ObjAndParam*>(data);
  objAndParam->obj->funcmain(objAndParam->param);
}
 
 
Простейший вариант:
Через data нужно передать как-то объект и параметры для вызова.
Значит перед вызовом нужно создать объект ObjAndParam и посетить
в него нужные данные.
Но дальше начинаются сложности.
Если мы отдаим указатель на объект на стеке - значит нужно
как-то гарантировать, что ThreadFun вызовытся до разрушения
этого объекта. Если его создавать динамически, то нужно
как-то гарантированно его удалять. + не забываем о том,
что объект пример должнен быть живым в момент вызова
метода из другого потока. Добавляем сюда обработку
всяких исключений и ошибок для надежной работы, добавляем
возможность это делать для объектов любых типов, для вызова
любых методов с любым (ну даже с ограниченным) количеством
аргументов любых типов - получаем хитрую шаблонную магию
и всякие другие фокусы для надежной работы. Осознаем что это
все достаточно сложно и возвращаемся к выбору какого-нибудь
готового решения.

#include <functional>
#include <memory>
#include <string>
#include <iostream>
 
//////////////////////////////////////////////////////
// аналог апишной функции. считаем что она запускает
// переданную функцию в отдельном потоке
typedef void (ThreadFuncPtr)(void*);
void RunThread(ThreadFuncPtr threadFunc, void* param)
{
  threadFunc(param);
}
//////////////////////////////////////////////////////
 
// наш класс помошник
class RunThreadHelper
{
  // если новый стандарт недоступен, то
  // этой штуке есть альтернатива:
  // абстрактный класс с одной функцией.
  // но std::function - удобнее.
  typedef std::function<void ()> Operation;
 
public:
  static void Run(Operation operation)
  {
    // когда и как освобождать этот op - придумайте сами.
    // в простейшем случае - в ThreadFunction если все пошло хорошо.
    Operation* op = new Operation(std::move(operation));
    RunThread(&RunThreadHelper::ThreadFunction, op);
  }
 
private:
  static void ThreadFunction(void* param)
  {
    std::unique_ptr<Operation> op(static_cast<Operation*>(param));
    (*op)();
  };
};
 
 
void FreeFunction1()
{
  std::cout << "FreeFunction1" << std::endl;
}
 
void FreeFunction2(int param)
{
  std::cout << "FreeFunction2: param = " << param << std::endl;
}
 
void FreeFunction3(int param1, const std::string& param2)
{
  std::cout << "FreeFunction3: param1 = " << param1 << "; param2 = " << param2 << std::endl;
}
 
class Test
{
  std::string m_name;
 
public:
  Test(const std::string& name)
    : m_name(name)
  {
  }
 
  void Function1()
  {
    std::cout << "Test::Function1: m_name = " << m_name << std::endl;
  }
 
  void Function2(int param)
  {
    std::cout << "Test::Function2: m_name = " << m_name << "; param = " << param << std::endl;
  }
 
  void Function3(int param1, const std::string& param2)
  {
    std::cout << "Test::Function3: m_name = " << m_name << "; param1 = " << param1 << "; param2 = " << param2 << std::endl;
  }
};
 
 
int main()
{
  Test test1("test1");
  Test test2("test1");
 
  RunThreadHelper::Run(&FreeFunction1);
 
  RunThreadHelper::Run(std::bind(&FreeFunction2, 2));
  RunThreadHelper::Run([] { FreeFunction2(22); });
  RunThreadHelper::Run(std::bind(&Test::Function1, &test1));
  RunThreadHelper::Run(std::bind(&Test::Function2, &test1, 2));
  RunThreadHelper::Run(std::bind(&Test::Function3, &test1, 2, "x"));
 
  RunThreadHelper::Run(std::bind(&FreeFunction3, 3, "x"));
  RunThreadHelper::Run([] { FreeFunction3(33, "xx"); });
  RunThreadHelper::Run([&test2] { test2.Function1(); });
  RunThreadHelper::Run([&test2] { test2.Function2(2); });
  RunThreadHelper::Run([&test2] { test2.Function3(22, "xx"); });
 
  return 0;
}

  static void ThreadFunction(void* param)
  {
    std::unique_ptr<Operation> op(static_cast<Operation*>(param));
    (*op)();
    // до сюда можем не дойти из-за исключения. нужно придумать как его не потерять
    // и донести до вызывающей стороны. какой-нибудь будущий результат из std использовать
    // или еще как-то.
  };