未解析的外部符号(构造函数)

你的代码中有很多错误，在此之前我建议你应该学习更多的c++基础知识。
正如我在评论中指出的错误一样，让我只用成员函数来回答您的问题:

c++将函数视为第一类公民，与Java相反(Java 8的改进修复了一些问题，但也没有将函数视为第一类公民)。
c++将函数理解为可调用实体的概念:可调用实体是任何可以被调用的东西，即作为函数处理。一个可调用的实体可以是:

• 一个全局函数:只是好的老C函数。它可以被定义、实现和调用:

  void f() {}
  int main()
  {
      f(); //Call to f
  }
  

• A成员函数:经典的OO成员函数。它在对象内部调用，并对其数据进行操作:

  struct foo
  {
      void f();   
  };
  int main()
  {
      foo myfoo;
      myfoo.f(); //Call to foo::f
  }
  

• 静态成员函数:它是一个没有链接到对象的成员函数，它在类级别操作，所以它的签名与全局函数的签名相同(记住这一点，这一点很重要，我们将在后面看到)

  struct foo
  {
      static void f();
  {
  int main()
  {
      foo::f(); //Call to foo::f
  }
  

• functor: functor只是一个类，它的对象被设计成像函数一样工作。这就实现了()操作符的重载:

  struct f
  {
      void operator()() const
      {}
  };
  int main()
  {
      f myf;
      myf(); //Call to foo
  }
  

  标准库定义了模板std::function，它是一个类型擦除的函子，用于保存任何类型的可调用实体:

  #include <functional>
  void f() {}
  int main()
  {
      std::function<void()> f_wrapper;
      f_wrapper(); //Call to f_wrapper, which is an indirect call to f
  } 
  

• lambda表达式: lambda表达式只是一个本地定义的匿名函子:

  int main()
  {
      std::function<void()> lambda = [](){ std::cout << "hello!"; };
  }
  

  你好!

• 指向函数的指针: C允许用户通过函数指针来存储函数，就像它允许存储指向数据的指针一样。c++也有相同的功能，并扩展为成员函数:

  void f() {}
  void g( void(*function)() ) 
  { 
      function(); //Call to the function referenced by the pointer passed as parameter 
  }
  int main()
  {
      g(f); //Call to g passing f as parameter. Its an indirect call to f. Note that the & is not needed
  }
  

  如前所述，静态成员函数与全局函数具有相同的签名，因此语法与上面的示例完全相同。
  但对于成员函数就不一样了:成员函数链接到对象，所以它在对象中被调用。成员函数指针的语法如下:

  struct foo
  {
      voif f();
  };
  typedef void(foo::* pointer_to_f_type)();
  int main()
  {
      pointer_to_f_pointer ptr = &foo::f; //Note that the & is needed, just like in variable pointers
      foo myfoo;
      (myfoo.*ptr)(); //Call to the foo member function pointed by ptr (foo::f) using myfoo as object
  }
  

  特定签名的成员函数指针与指向相同签名的全局/静态函数的指针无关，不能从/转换为成员指针到非成员指针，反之亦然。

  因为函数指针和成员函数指针是完全分开的东西，所以不能处理任何类型的函数直接以齐次的方式。例如，不能创建既包含函数指针又包含成员函数指针的数组。然而，标准库提供了函数模板std::bind，它允许我们将函数绑定到一些(或全部)调用形参。也就是说，std::bind()返回的对象表示对可调用实体的部分(或完整)调用。例如:

   void f( int , int , int ) {}
   int main()
   {
       std::function<void(int,int,int)> f_wrapper = f;
       f(1,2,3); //Ok
       f_wrapper(1,2,3); //Ok
       std::function<void()> f_call = std::bind( f , 1 , 2 , 3 ); //f_call represents a partial call (Complete in this case) fo f
       f_call(); //Execute the call
       std::function<void(int)> partial_f_call = std::bind( f , std::placeholders::_1 , 2 , 3 );
       partial_f_call( 1 ); //Same execution as above
   } 
  

  正如您所看到的，std::bind()允许我们将某些参数绑定到函数，使一个可调用的实体表示对函数的调用。因此，可用于将对象绑定到成员函数，从而形成可调用实体使用与其他可调用实体初始化的std::function实例完全相同的形式。即我们可以使用std::function以同样的方式存储成员函数和非成员函数，并以同样的方式使用它**:

   void f();
   struct foo
   {
       void f();
   };
   int main()
   {
       std::vector<std::function<void()>> functions;
       foo myfoo;
       functions.push_back( f );
       functions.push_back( std::bind( &foo::f , myfoo ) );
       functions.push_back( [](){} );
       ...
       for( const auto& function : functions )
           function();
   }
  

可以看到，有多种形式的可调用实体。重要的一点是，有人可以使用c++模板并依赖于duck类型来使用可调用对象作为参数传递的实体:

 template<typename F>
 void call_function( const F& function )
 {
     function(); //function should be any kind of thing which could be called, that is, a callable entity
 } 

这正是std::thread构造函数所做的。它接受任何可调用的实体，一组调用的参数，启动一个新线程，然后在新线程上调用可调用实体(通过join()或detach())。它的实现可以是这样的:

template<typename F , typename... ARGS>
thread::thread( F&& function , ARGS&&... args )
{
    _thread = create_thread();
    _function = std::bind( std::forward<F>( function ) , std::forward<ARGS>( args )... ); 
}

void thread::detach()
{
    detach_thread( _thread );
    _function();
}
void thread::join()
{
    join_thread( _thread );
    _function();
}

当然这不是一个工作实现，只是一个概述:p

所以现在你可以理解为什么你的方法不起作用，以及你可以做些什么来解决这个问题。具体来说，使用std::bind()来创建一个可调用的实体如果你想在线程上使用成员函数，