C++：nitty-gritty place in the Standard Thread Library

Scenario 1:

void f(int i,const string s);
void oops(int some_param)
{
    char buffer[1024];
    sprintf(buffer,"%i",some_param);
    std::thread t(f,3,buffer);
    t.detach();
}

The problem is, there's a significant chance that the function  oops will exit before the  buffer  has been converted to a  std::string ,thus leading to undefined behavior. Note that in this case, the constructor of  std::thread just copies the supplied values(which is  buffer  the pointer) as is, without converting it to the expected argument type. That conversion is left to to function  f  itself. So after the constructor of  std::thread copy  buffer and before  buffer  be converted to  std::string , function  oops may have exited and  buffer  would be destroyed then, making the convertion afterward illegal.

Scenario 2 (to pass reference as parameter to a thread function):

void update_data_for_widget(widget_id w, widget_data& data);

void oops_again(widget_id w)
{
    widget_data data;
    std::thread t(update_data_for_widget,w,data);
    do_something();
    t.join();
    process_widget_data(data);
}

Obviously, in line 6,  data would be pass as a copy rather than a reference to function  update_data_for_widget . To really pass it as a reference, you have to do this:

std::thread t(update_data_for_thread,w,std::ref(data));

Scenario 3( Using member function as a thread function ) :

Note that the behavior of  std::thread  constructor is defined in terms of the same mechanism as the operation of  std::bind . This means that, for example, you can pass a member function pointer as the function, provided you supplied a suitable object pointer as the first argument：

class X
{
public:
    void do_some_work();
};

X my_x;
std::thread t(&X::do_some_work,&my_x);   //If you don't know how can this be, check std::bind

This code would invoke  my_x.do_some_work() on the new thread, because the address of  my_x is supplied as the object pointer( If you don't know how can this be, check  std::bind  )

You can also supply arguments to such a member function call: the third argument to the  std::thread constructor would be the first argument to the member function and so forth.

:)