Vorbei Objekt über eine Referenz auf std::thread in C++11

Warum kann man nicht ein Objekt übergeben durch Referenz beim erstellen einer std::thread ?

Zum Beispiel den folgenden snippit gibt einen compile-Fehler:

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

Fehler:

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

Habe ich geändert, wird ein Zeiger übergeben, aber gibt es eine bessere Lösung?

InformationsquelleAutor austinmarton | 2015-12-03

  1. 49

    Explizit initialisiert das Faden mit einem reference_wrapper mit , std::ref:

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

    (oder std::cref statt std::ref als geeignet). Pro Noten von cppreference auf std:thread:

    Argumente für die thread-Funktion verschieben oder kopieren von Wert. Wenn ein Referenz-argument übergeben werden muss, um die thread-Funktion, es muss gewickelt werden (z.B. mit std::ref oder std::cref).

    Das erfassen, sinnvoll, Standards zu erfassen die von Wert, denn sonst würden die Dinge scheitern schrecklich, wenn der parameter ging Weg, bevor der thread kann es Lesen. Müssen Sie explizit Fragen, für die dieses Verhalten so, dass es etwas gibt, um anzuzeigen, dass Sie die Verantwortung dafür, dass das Ziel der Referenz ist immer noch gültig.
    Ausgezeichnet! Ich hatte gehofft, es war ein Weg, um explizit übergeben Sie einen Verweis. C++11 ist die Rettung wieder 🙂

    InformationsquelleAutor ShadowRanger

  2. 3

    Basierend auf dieser Kommentar, diese Antwort näher auf den Grund, warum die Argumente nicht übergeben durch Verweis an die thread-Funktion standardmäßig.

    Betrachten Sie die folgende Funktion SimpleThread():

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

    Nun, sich vorstellen, was passieren würde, wenn Sie den folgenden code zusammengestellt (es tut nicht kompilieren):

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

    Dem argument a übergeben werden würde durch Verweis auf SimpleThread(). Der thread kann noch schlafen in der Funktion SimpleThread() nach der variable a hat bereits erloschen, der Geltungsbereich und die Lebensdauer zu Ende ist. Wenn dem so ist, i im SimpleThread() wäre eigentlich eine baumelnden Referenz, und die Zuordnung i = 0 führen würde Undefiniertes Verhalten.

    Durch die Verpackung Referenz-Argumente mit der Vorlage-Klasse std::reference_wrapper (über die Funktion Vorlagen std::ref und std::cref) Sie ausdrücklich Ihre Absichten.

    InformationsquelleAutor El Profesor

Schreibe einen Kommentar