Pasar objeto por referencia a std:: thread en C++ 11

c++11 pass-by-reference

Question

¿Por qué no puede pasar un objeto por referencia al crear un std::thread ?

Por ejemplo, el siguiente fragmento proporciona un error de compilación:

#include <iostream>
#include <thread>

using namespace std;

static void SimpleThread(int& a)  // compile error
//static void SimpleThread(int a)     // OK
{
    cout << __PRETTY_FUNCTION__ << ":" << a << endl;
}

int main()
{
    int a = 6;

    auto thread1 = std::thread(SimpleThread, a);

    thread1.join();
    return 0;
}

Error:

In file included from /usr/include/c++/4.8/thread:39:0,
                 from ./std_thread_refs.cpp:5:
/usr/include/c++/4.8/functional: In instantiation of ‘struct std::_Bind_simple<void (*(int))(int&)>’:
/usr/include/c++/4.8/thread:137:47:   required from ‘std::thread::thread(_Callable&&, _Args&& ...) [with _Callable = void (&)(int&); _Args = {int&}]’
./std_thread_refs.cpp:19:47:   required from here
/usr/include/c++/4.8/functional:1697:61: error: no type named ‘type’ in ‘class std::result_of<void (*(int))(int&)>’
       typedef typename result_of<_Callable(_Args...)>::type result_type;
                                                             ^
/usr/include/c++/4.8/functional:1727:9: error: no type named ‘type’ in ‘class std::result_of<void (*(int))(int&)>’
         _M_invoke(_Index_tuple<_Indices...>)
         ^

He cambiado a pasar un puntero, pero ¿hay una mejor solución?

Answer 1

En base a este comentario , esta respuesta desarrolla la razón por la cual los argumentos no se pasan por referencia a la función de hilo de forma predeterminada .

Considere la siguiente función SimpleThread() :

void SimpleThread(int& i) {
    std::this_thread::sleep_for(std::chrono::seconds{1});
    i = 0;
}

Ahora, imagine lo que sucedería si se compilara el siguiente código (no se compila):

int main()
{
    {
        int a;
        std::thread th(SimpleThread, a);
        th.detach();
    }
    // "a" is out of scope
    // at this point the thread may be still running
    // ...
}

El argumento a se pasaría por referencia a SimpleThread() . El subproceso aún puede estar SimpleThread() en la función SimpleThread() después de que la variable a ya se haya salido del alcance y haya finalizado su vida útil. Si es así, i en SimpleThread() sería en realidad una referencia pendiente , y la asignación i = 0 daría lugar a un comportamiento indefinido .

Al ajustar los argumentos de referencia con la plantilla de clase std::reference_wrapper (usando las plantillas de función std::ref y std::cref ) expresas explícitamente tus intenciones.

Answer 2

Inicializa explícitamente el hilo con una reference_wrapper usando std::ref :

auto thread1 = std::thread(SimpleThread, std::ref(a));

(o std::cref lugar de std::ref , según corresponda). Por notas de cppreference en std:thread :

Los argumentos de la función de subproceso se mueven o copian por valor. Si se necesita pasar un argumento de referencia a la función de subproceso, debe envolverse (por ejemplo, con std::ref o std::cref ).