1、传递临时对象作为线程参数

    1. #include<iostream>
    2. #include<thread>
    3. using namespace std;
    5. void myPrint(const int& i, char* pmyBuf)
    6. {
    7.     cout << i << endl;
    8.     cout << pmyBuf << endl;
    9. }
    11. int main()
    12. {
    13.     int mvar = 1;
    14.     int& mvary = mvar;
    15.     char mybuf[] = "this is a test!";
    16.     thread mytobj(myPrint, mvar, mybuf);
    17.     mytobj.detach();
    18.     return 0;
    19. }

    根据debug分析，myPrint中的i并不是mvar的引用，实际是值传递。所以，即便主线程detach了子线程，那么子线程中用的i值仍然是安全的。
    但是myPrint的第二个参数指针指向的是同一个地址，因此在detach时，主线程结束了，mybuf的内存被回收了，因此会报错。所以，线程的值传递不建议传递指针，同时也不建议传递引用。

    1. #include<iostream>
    2. #include<thread>
    3. #include<string>
    4. using namespace std;
    6. void myPrint(const int& i, const string& pmyBuf)
    7. {
    8.     cout << i << endl;
    9.     cout << pmyBuf << endl;
    10. }
    12. int main()  
    13. {
    14.     int mvar = 1;
    15.     int& mvary = mvar;
    16.     char mybuf[] = "this is a test!";
    17.     //thread mytobj(myPrint, mvar, mybuf); 不稳定
    18.     thread mytobj(myPrint, mvar, string(mybuf));
    19.     mytobj.detach();
    20.     return 0;
    21. }

    事实上是存在，mybuf都被回收了，系统采用mybuf去转string。因此要在给线程传参是创建一个临时的string对象。