C++ 11 Inicjowanie wątków przy kompilacji funkcji składowych członkowskich

Question

Właśnie zaczynam używać wątków C++ 11 i walczyłem (prawdopodobnie głupio) o błąd. To jest mój przykładowy program:

#include <iostream> 
#include <thread> 
#include <future> 
using namespace std; 

class A { 
public: 
    A() { 
    cout << "A constructor\n"; 
    } 

    void foo() { 
    cout << "I'm foo() and I greet you.\n"; 
    } 

    static void foo2() { 
    cout << "I'm foo2() and I am static!\n"; 
    } 

    void operator()() { 
    cout << "I'm the operator(). Hi there!\n"; 
    } 
}; 

void hello1() { 
    cout << "Hello from outside class A\n"; 
} 

int main() { 
    A obj; 
    thread t1(hello1); // it works 
    thread t2(A::foo2); // it works 
    thread t3(obj.foo); // error 
    thread t4(obj);  // it works 

    t1.join(); 
    t2.join(); 
    t3.join(); 
    t4.join(); 
    return 0; 
} 

Czy to możliwe, aby rozpocząć wątek z czystego funkcji członkiem? Jeśli tak nie jest, w jaki sposób mogę zawinąć funkcję foo z obiektu obj, aby móc utworzyć taki wątek? Z góry dziękuję!

Jest to błąd kompilacji:

thread_test.cpp: In function ‘int main()’: thread_test.cpp:32:22: error: no matching function for call to ‘std::thread::thread()’

thread_test.cpp:32:22: note: candidates are:

/usr/include/c++/4.6/thread:133:7: note: std::thread::thread(_Callable&&, _Args&& ...) [with _Callable = void (A::*)(), _Args = {}]

/usr/include/c++/4.6/thread:133:7: note: no known conversion for argument 1 from ‘’ to ‘void (A::*&&)()’

/usr/include/c++/4.6/thread:128:5: note: std::thread::thread(std::thread&&)

/usr/include/c++/4.6/thread:128:5: note: no known conversion for argument 1 from ‘’ to ‘std::thread&&’

/usr/include/c++/4.6/thread:124:5: note: std::thread::thread()

/usr/include/c++/4.6/thread:124:5: note: candidate expects 0 arguments, 1 provided

Answer 1

Musisz wpłacone obiekt sobą nie parametry, więc

thread t3(&A::foo, &obj); 

powinno załatwić sprawę. Powoduje to utworzenie jednostki, którą można wywołać, która wywołuje A::foo na na .

Powodem jest to, że niestatyczna funkcja składowa A przyjmuje domyślny pierwszy parametr typu (prawdopodobnie kwalifikowany cv) A*. Po wywołaniu obj.foo() skutecznie dzwonisz pod numer A::foo(&obj). Kiedy już to wiesz, powyższe zaklęcie ma sens.