Démarrer le fil avec la fonction membre

Question

J'essaie d'exécuter un std::thread avec une fonction membre qui renvoie void() . Je ne parviens pas à déterminer la syntaxe utilisée - le compilateur se plaint quoi qu'il arrive. Quelle est la bonne façon de générer une fonction membre sans argument via std::thread ?

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

Answer 1

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

EDIT: La comptabilité de votre montage, vous devez le faire comme ceci:

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

---

Mise à JOUR: je tiens à expliquer certains points de plus, certains d'entre eux ont également été discuté dans les commentaires.

La syntaxe décrite ci-dessus est défini en termes d'INVOQUER définition (§20.8.2.1):

Définir INVOKE (f, t1, t2, ..., tN) comme suit:

• (t1.*f)(t2, ..., tN) si f est un pointeur vers une fonction membre d'une classe T et t1 est un objet de type T ou une référence à un objet de type T ou une référence à un objet d'un type dérivé de T;
• ((*t1).*f)(t2, ..., tN) si f est un pointeur vers une fonction membre d'une classe T et t1 n'est pas l'un des types décrits dans le précédent élément;
• t1.*f lorsque N == 1 et f est un pointeur vers les données membres d'une classe T et t 1 est un objet de type T ou un
  référence à un objet de type T ou une référence à un objet d'une
  type dérivé de T;
• (*t1).*f lorsque N == 1 et f est un pointeur vers les données membres d'une classe T et t 1 n'est pas l'un des types décrits dans l'article précédent;
• f(t1, t2, ..., tN) dans tous les autres cas.

---

Un autre fait qui, je tiens à souligner est que, par défaut, le thread constructeur de copie de tous les arguments passés à elle. La raison pour cela est que les arguments peuvent avoir besoin pour survivre le thread appelant, en copiant les arguments des garanties. Au lieu de cela, si vous voulez vraiment passer une référence, vous pouvez utiliser un std::reference_wrapper créé par std::ref.

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

En faisant cela, vous promettant que vous allez prendre soin de garantir que les arguments existent encore lorsque le thread opère sur eux.

---

Notez que toutes les choses mentionnées ci-dessus peuvent également être appliquées à d' std::async et std::bind.

Answer 2

Si vous utilisez C ++ 11, lambda-expression est une solution agréable et propre.

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

le this-> peut être omis.

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

ou juste

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

Je pense que le fait d’emballer le retour expr avec std::move(...) est préférable. Si votre code peut compiler, cela devrait être RVO (optimisation de la valeur de retour). Cependant, je pense que cela ne devrait pas être le cas, car std::thread n'a pas de constructeur de copies.

Answer 3

utiliser std::bind :

std::thread mythread((std::bind( &myclass::mymemfunction, myclassobjectpointer)))