web-dev-qa-db-fra.com

Passer un objet par référence à std :: thread en C ++ 11

Pourquoi ne pouvez-vous pas passer un objet par référence lors de la création d'un std::thread?

Par exemple, l'extrait de code suivant donne une erreur de compilation:

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

Erreur:

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

J'ai changé pour passer un pointeur, mais y a-t-il une meilleure solution?

c++c++11pass-by-referencestdthread
38
austinmarton

Initialiser explicitement le thread avec un reference_wrapper en utilisant std::ref :

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

(ou std::cref au lieu de std::ref, selon le cas). Par notes de cppreference on std:thread :

Les arguments de la fonction de thread sont déplacés ou copiés par valeur. Si un argument de référence doit être passé à la fonction thread, il doit être encapsulé (par exemple avec std::ref ou std::cref).

53
ShadowRanger

Sur la base de ce commentaire , cette réponse explique la raison pour laquelle les arguments ne sont pas passés par référence à la fonction de thread par défaut .

Considérez la fonction suivante SimpleThread():

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

Maintenant, imaginez ce que se produirait si le code suivant est compilé (il ne compile pas ):

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
    // ...
}

L'argument a serait passé par référence à SimpleThread(). Le thread peut toujours dormir dans la fonction SimpleThread() une fois que la variable a est déjà hors de portée et que sa durée de vie est terminée. Si c'est le cas, i dans SimpleThread() serait en fait une référence suspendue, et l'affectation i = 0 Entraînerait undefined comportement.

En enveloppant les arguments de référence avec le modèle de classe std::reference_wrapper (En utilisant les modèles de fonction std::ref Et std::cref), Vous exprimez explicitement vos intentions.

8
El Profesor