Rozpocznij wątek za pomocą funkcji członka

Próbuję zbudować std::threadz funkcją członka, która nie przyjmuje argumentów i zwraca void. Nie mogę znaleźć żadnej składni, która działa - kompilator narzeka bez względu na wszystko. Jaki jest prawidłowy sposób zaimplementowania spawn(), std::threadaby zwracał wykonanie test()?

#include <thread>
class blub {
  void test() {
  }
public:
  std::thread spawn() {
    return { test };
  }
};

#include <thread>
#include <iostream>

class bar {
public:
  void foo() {
    std::cout << "hello from member function" << std::endl;
  }
};

int main()
{
  std::thread t(&bar::foo, bar());
  t.join();
}

EDYCJA: Uwzględniając swoją edycję, musisz to zrobić w następujący sposób:

  std::thread spawn() {
    return std::thread(&blub::test, this);
  }

AKTUALIZACJA: Chcę wyjaśnić kilka innych kwestii, niektóre z nich zostały również omówione w komentarzach.

Opisana powyżej składnia jest zdefiniowana w kategoriach INVOKE (§20.8.2.1):

Zdefiniuj INVOKE (f, t1, t2, ..., tN) w następujący sposób:

• (t1. * f) (t2, ..., tN), gdy f jest wskaźnikiem funkcji składowej klasy T, a t1 jest obiektem typu T lub odniesieniem do obiektu typu T lub odwołaniem do obiekt typu pochodzący od T;
• ((* t1). * f) (t2, ..., tN), gdy f jest wskaźnikiem funkcji składowej klasy T, a t1 nie jest jednym z typów opisanych w poprzednim punkcie;
• t1. * f gdy N == 1 if jest wskaźnikiem do danych elementu klasy T, a t 1 jest obiektem typu T lub
  odniesieniem do obiektu typu T lub odniesieniem do obiektu
  typu uzyskanego z T;
• (* t1). * f gdy N == 1 if jest wskaźnikiem do danych elementu klasy T, a t 1 nie jest jednym z typów opisanych w poprzednim punkcie;
• f (t1, t2, ..., tN) we wszystkich pozostałych przypadkach.

Innym ogólnym faktem, na który chcę zwrócić uwagę, jest to, że domyślnie konstruktor wątków kopiuje wszystkie przekazane mu argumenty. Powodem tego jest to, że argumenty mogą potrzebować przeżyć wątek wywołujący, kopiowanie argumentów gwarantuje to. Zamiast tego, jeśli naprawdę chcesz przekazać referencję, możesz użyć std::reference_wrapperutworzonego przez std::ref.

std::thread (foo, std::ref(arg1));

Robiąc to, obiecujesz, że zadbasz o to, aby argumenty nadal istniały, gdy wątek na nich działa.

Pamiętaj, że wszystkie wyżej wymienione rzeczy można również zastosować do std::asynci std::bind.

Ponieważ używasz C ++ 11, wyrażenie lambda jest ładnym i czystym rozwiązaniem.

class blub {
    void test() {}
  public:
    std::thread spawn() {
      return std::thread( [this] { this->test(); } );
    }
};

ponieważ this->można go pominąć, można go skrócić do:

std::thread( [this] { test(); } )

Lub tylko

std::thread( [=] { test(); } )

Oto kompletny przykład

#include <thread>
#include <iostream>

class Wrapper {
   public:
      void member1() {
          std::cout << "i am member1" << std::endl;
      }
      void member2(const char *arg1, unsigned arg2) {
          std::cout << "i am member2 and my first arg is (" << arg1 << ") and second arg is (" << arg2 << ")" << std::endl;
      }
      std::thread member1Thread() {
          return std::thread([=] { member1(); });
      }
      std::thread member2Thread(const char *arg1, unsigned arg2) {
          return std::thread([=] { member2(arg1, arg2); });
      }
};
int main(int argc, char **argv) {
   Wrapper *w = new Wrapper();
   std::thread tw1 = w->member1Thread();
   std::thread tw2 = w->member2Thread("hello", 100);
   tw1.join();
   tw2.join();
   return 0;
}

Kompilacja z g ++ daje następujący wynik

g++ -Wall -std=c++11 hello.cc -o hello -pthread

i am member1
i am member2 and my first arg is (hello) and second arg is (100)

@ hop5 i @RnMss sugerują użycie lambd C ++ 11, ale jeśli masz do czynienia ze wskaźnikami, możesz użyć ich bezpośrednio:

#include <thread>
#include <iostream>

class CFoo {
  public:
    int m_i = 0;
    void bar() {
      ++m_i;
    }
};

int main() {
  CFoo foo;
  std::thread t1(&CFoo::bar, &foo);
  t1.join();
  std::thread t2(&CFoo::bar, &foo);
  t2.join();
  std::cout << foo.m_i << std::endl;
  return 0;
}

wyjścia

2

Przepisana próbka z tej odpowiedzi będzie wtedy:

#include <thread>
#include <iostream>

class Wrapper {
  public:
      void member1() {
          std::cout << "i am member1" << std::endl;
      }
      void member2(const char *arg1, unsigned arg2) {
          std::cout << "i am member2 and my first arg is (" << arg1 << ") and second arg is (" << arg2 << ")" << std::endl;
      }
      std::thread member1Thread() {
          return std::thread(&Wrapper::member1, this);
      }
      std::thread member2Thread(const char *arg1, unsigned arg2) {
          return std::thread(&Wrapper::member2, this, arg1, arg2);
      }
};

int main() {
  Wrapper *w = new Wrapper();
  std::thread tw1 = w->member1Thread();
  tw1.join();
  std::thread tw2 = w->member2Thread("hello", 100);
  tw2.join();
  return 0;
}

Niektórzy użytkownicy już udzielili odpowiedzi i wyjaśnili ją bardzo dobrze.

Chciałbym dodać jeszcze kilka rzeczy związanych z wątkiem.

1. Jak pracować z funktorem i wątkiem. Proszę odnieść się do poniższego przykładu.

2. Wątek utworzy własną kopię obiektu podczas przekazywania obiektu.

   #include<thread>
   #include<Windows.h>
   #include<iostream>
   
   using namespace std;
   
   class CB
   {
   
   public:
       CB()
       {
           cout << "this=" << this << endl;
       }
       void operator()();
   };
   
   void CB::operator()()
   {
       cout << "this=" << this << endl;
       for (int i = 0; i < 5; i++)
       {
           cout << "CB()=" << i << endl;
           Sleep(1000);
       }
   }
   
   void main()
   {
       CB obj;     // please note the address of obj.
   
       thread t(obj); // here obj will be passed by value 
                      //i.e. thread will make it own local copy of it.
                       // we can confirm it by matching the address of
                       //object printed in the constructor
                       // and address of the obj printed in the function
   
       t.join();
   }

Innym sposobem osiągnięcia tego samego jest:

void main()
{
    thread t((CB()));

    t.join();
}

Ale jeśli chcesz przekazać obiekt przez referencję, użyj poniższej składni:

void main()
{
    CB obj;
    //thread t(obj);
    thread t(std::ref(obj));
    t.join();
}