2.2 传递参数

如代码2.4所示，向可调用对象或函数传递参数很简单，只需要将这些参数作为 std::thread构造函数的附加参数即可。需要注意的是，这些参数会拷贝至新线程的内存空间中(同临时变量一样)。即使函数中的参数是引用的形式，拷贝操作也会执行。来看一个例子：

  1. void f(int i, std::string const& s);
  2. std::thread t(f, 3, "hello");

代码创建了一个调用f(3, “hello”)的线程。注意，函数f需要一个std::string对象作为第二个参数，但这里使用的是字符串的字面值，也就是char const *类型，线程的上下文完成字面值向std::string的转化。需要特别注意，指向动态变量的指针作为参数的情况，代码如下：

  1. void f(int i,std::string const& s);
  2. void oops(int some_param)
  3. {
  4.   char buffer[1024]; // 1
  5.   sprintf(buffer, "%i",some_param);
  6.   std::thread t(f,3,buffer); // 2
  7.   t.detach();
  8. }

buffer①是一个指针变量，指向局部变量，然后此局部变量通过buffer传递到新线程中②。此时，函数oops可能会在buffer转换成std::string之前结束，从而导致未定义的行为。因为，无法保证隐式转换的操作和std::thread构造函数的拷贝操作的顺序，有可能std::thread的构造函数拷贝的是转换前的变量(buffer指针)。解决方案就是在传递到std::thread构造函数之前，就将字面值转化为std::string：

  1. void f(int i,std::string const& s);
  2. void not_oops(int some_param)
  3. {
  4.   char buffer[1024];
  5.   sprintf(buffer,"%i",some_param);
  6.   std::thread t(f,3,std::string(buffer));  // 使用std::string，避免悬空指针
  7.   t.detach();
  8. }

相反的情形(期望传递一个非常量引用，但复制了整个对象)倒是不会出现，因为会出现编译错误。比如，尝试使用线程更新引用传递的数据结构：

  1. void update_data_for_widget(widget_id w,widget_data& data); // 1
  2. void oops_again(widget_id w)
  3. {
  4.   widget_data data;
  5.   std::thread t(update_data_for_widget,w,data); // 2
  6.   display_status();
  7.   t.join();
  8.   process_widget_data(data);
  9. }

虽然update_data_for_widget①的第二个参数期待传入一个引用，但std::thread的构造函数②并不知晓，构造函数无视函数参数类型，盲目地拷贝已提供的变量。不过，内部代码会将拷贝的参数以右值的方式进行传递，这是为了那些只支持移动的类型，而后会尝试以右值为实参调用update_data_for_widget。但因为函数期望的是一个非常量引用作为参数(而非右值)，所以会在编译时出错。对于熟悉std::bind的开发者来说，问题的解决办法很简单：可以使用std::ref将参数转换成引用的形式。因此可将线程的调用改为以下形式：

  1. std::thread t(update_data_for_widget,w,std::ref(data));

这样update_data_for_widget就会收到data的引用，而非data的拷贝副本，这样代码就能顺利的通过编译了。

如果熟悉std::bind，就应该不会对以上述传参的语法感到陌生，因为std::thread构造函数和std::bind的操作在标准库中以相同的机制进行定义。比如，你也可以传递一个成员函数指针作为线程函数，并提供一个合适的对象指针作为第一个参数：

  1. class X
  2. {
  3. public:
  4.   void do_lengthy_work();
  5. };
  6. X my_x;
  7. std::thread t(&X::do_lengthy_work, &my_x); // 1

这段代码中，新线程将会调用my_x.do_lengthy_work()，其中my_x的地址①作为对象指针提供给函数。也可以为成员函数提供参数：std::thread构造函数的第三个参数就是成员函数的第一个参数，以此类推(代码如下，译者自加)。

  1. class X
  2. {
  3. public:
  4.   void do_lengthy_work(int);
  5. };
  6. X my_x;
  7. int num(0);
  8. std::thread t(&X::do_lengthy_work, &my_x, num);

另一种有趣的情形是，提供的参数仅支持移动(move)，不能拷贝。“移动”是指原始对象中的数据所有权转移给另一对象，从而这些数据就不再在原始对象中保存(译者：比较像在文本编辑的剪切操作)。std::unique_ptr就是这样一种类型(译者：C++11中的智能指针)，这种类型为动态分配的对象提供内存自动管理机制(译者：类似垃圾回收机制)。同一时间内，只允许一个std::unique_ptr实例指向一个对象，并且当这个实例销毁时，指向的对象也将被删除。移动构造函数(move constructor)和移动赋值操作符(move assignment operator)允许一个对象的所有权在多个std::unique_ptr实例中传递(有关“移动”的更多内容，请参考附录A的A.1.1节)。使用“移动”转移对象所有权后，就会留下一个空指针。使用移动操作可以将对象转换成函数可接受的实参类型，或满足函数返回值类型要求。当原对象是临时变量时，则自动进行移动操作，但当原对象是一个命名变量，转移的时候就需要使用std::move()进行显示移动。下面的代码展示了std::move的用法，展示了std::move是如何转移动态对象的所有权到线程中去的：

  1. void process_big_object(std::unique_ptr<big_object>);
  3. std::unique_ptr<big_object> p(new big_object);
  4. p->prepare_data(42);
  5. std::thread t(process_big_object,std::move(p));

通过在std::thread构造函数中执行std::move(p)，big_object 对象的所有权首先被转移到新创建线程的的内部存储中，之后再传递给process_big_object函数。

C++标准线程库中和std::unique_ptr在所属权上相似的类有好几种，std::thread为其中之一。虽然，std::thread不像std::unique_ptr能占有动态对象的所有权，但是它能占有其他资源：每个实例都负责管理一个线程。线程的所有权可以在多个std::thread实例中转移，这依赖于std::thread实例的可移动且不可复制性。不可复制性表示在某一时间点，一个std::thread实例只能关联一个执行线程。可移动性使得开发者可以自己决定，哪个实例拥有线程实际执行的所有权。