rvalues - Passando objeto por referência a std:: thread em C++ 11



thread c++ class example (2)

Por que você não pode passar um objeto por referência ao criar um std::thread ?

Por exemplo, o seguinte trecho dá um erro de compilação:

#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;
}

Erro:

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...>)
         ^

Eu mudei para passar um ponteiro, mas há um trabalho melhor ao redor?


Answer #1

Com base nesse comentário , essa resposta elabora o motivo pelo qual os argumentos não são passados por referência à função thread por padrão .

Considere a seguinte função SimpleThread() :

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

Agora, imagine o que aconteceria se o código a seguir fosse compilado ( não 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
    // ...
}

O argumento a seria passado por referência a SimpleThread() . O thread ainda pode estar dormindo na função SimpleThread() depois que a variável a já saiu do escopo e seu tempo de vida terminou. Se assim for, i em SimpleThread() seria na verdade uma referência pendente e a atribuição i = 0 resultaria em um comportamento indefinido .

Ao envolver argumentos de referência com o modelo de classe std::reference_wrapper (usando os modelos de função std::ref e std::cref ), você expressa expressamente suas intenções.


Answer #2

Inicialize explicitamente o segmento com um reference_wrapper usando std::ref :

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

(ou std::cref vez de std::ref , conforme apropriado). Por notas da cppreference no std:thread :

Os argumentos para a função de thread são movidos ou copiados por valor. Se um argumento de referência precisa ser passado para a função thread, ele deve ser empacotado (por exemplo, com std::ref ou std::cref ).





stdthread