La création d'un boost::thread avec boost::bind() ou sans elle

Certaines personnes semblent lancer boost::threads à l'aide de la boost::bind() de la fonction, comme dans la accepté de répondre à la question suivante:

Utilisation de boost thread et non statique de la fonction de classe

Alors que d'autres personnes ne l'utilisez pas du tout, comme dans la réponse à la plupart des upvotes de cette question:

La meilleure façon de commencer un thread en tant que membre d'une classe C++?

Alors, quelle est la différence, si elle existe?

Donc, je pense que vous êtes vraiment se demander pourquoi utiliser Boost pour les threads sur (native) p-fils?
Non, je pense qu'il est de se demander pourquoi utiliser bind plutôt que de le laisser boost::thread constructeur de faire tout le travail. (Et je suis sûr que vous devez utiliser bind si vous souhaitez démarrer le thread à l'aide d'un shared_ptr.)

OriginalL'auteur deinocheirus | 2012-12-06

  1. 12

    Comme vous pouvez le voir par le code ci-dessous qui compile et donne les résultats attendus, boost::bind est complètement inutile pour l'utilisation de boost::thread avec gratuit fonctions, les fonctions de membres et de fonctions membres statiques:

    #include <boost/thread/thread.hpp>
#include <iostream>

void FreeFunction()
{
  std::cout << "hello from free function" << std::endl;
}

struct SomeClass
{
  void MemberFunction()
  {
    std::cout << "hello from member function" << std::endl;
  }

  static void StaticFunction()
  {
    std::cout << "hello from static member function" << std::endl;
  }
};

int main()
{
  SomeClass someClass;

  //this free function will be used internally as is
  boost::thread t1(&FreeFunction);
  t1.join();

  //this static member function will be used internally as is
  boost::thread t2(&SomeClass::StaticFunction);
  t2.join();

  //boost::bind will be called on this member function internally
  boost::thread t3(&SomeClass::MemberFunction, someClass);
  t3.join();
}

    De sortie:

    hello from free function
hello from static member function
hello from member function

    Interne lier dans le constructeur fait tout le travail pour vous.

    Juste ajouté un supplément de quelques commentaires sur ce qui se passe avec chaque type de fonction. (J'espère que j'ai pu lire correctement la source!) Aussi loin que je peux voir, à l'aide de boost::bind de l'extérieur ne sera pas cause de double et d'être appelée en interne, car il sera de passer à travers.

    Alors pourquoi les gens utilisent-ils? Ce boost::asio exemple utilise bind (): boost.org/doc/libs/1_52_0/doc/html/boost_asio/example/chat/...
    cela peut dépendre de la version de boost. La variante sans std::bind nécessite une forme de variadic template émulation.
    Il a été pris en charge au moins aussi loin que 2008 occording à Anthony Williams Dr Dobbs article sur coup de pouce.Thrads: drdobbs.com/cpp/whats-new-in-boost-threads/211600441 je soupçonne les gens le font par pure habitude. Sans chercher à la source, cela signifie probablement boost::bind est appelé deux fois, si vous l'utilisez à l'extérieur.
    Que penser de l'utilisation d'un shared_ptr pour appeler une fonction membre? Qu'il n'assure qu'une copie du pointeur partagé reste portée par l'exécution de la fonction de membre?
    Les gens utilisent probablement boost::bind parce qu'ils sont pas au courant de boost::threadinternes lier

    OriginalL'auteur goji

  2. 10

    Il n'y a pas de différence - thread constructeur utilise bind en interne.
    Les gens utilisent bind explicitement pour des raisons historiques, car Boost.Thread n'ai pas "la liaison" constructeur avant de 1.36.

    OriginalL'auteur Igor R.

  3. 1

    La boost::bind est utilisée pour lier une fonction membre à un fil, alors que sans boost::bind, normalement, vous êtes à l'aide d'une fonction statique ou une fonction libre avec le fil.

    OriginalL'auteur Tony The Lion

  4. 1

    Alors, quelle est la différence, si elle existe?

    La principale différence est quoi avez-vous besoin d'accéder à l'intérieur de la fonction de thread.

    Si votre conception exige que vous avez accès à une instance de classe de données, puis de lancer votre fil dans le cadre d'une instance de classe (utilisation boost::bind avec this et une fonction membre, ou d'une fonction membre statique avec un void* mappé à this - c'est une affaire de style pour la plupart).

    Si votre conception exige que la fonction de thread n'est pas dépendant d'un objet particulier de données, puis utiliser une fonction libre.

    OriginalL'auteur utnapistim

  5. 0

    La différence principale est de savoir si vous voulez de l'interface statique ou non des fonctions de membre statique. Si vous voulez utiliser des fonctions membres statiques comme la fonction lancée par le thread, vous devez utiliser quelque chose comme bind.

    L'alternative proposée (la deuxième question que vous avez mis en lien) est d'utiliser une méthode statique qui prend un pointeur vers l'objet de classe et peut en appeler l'un de ses membres. Cela efface la syntaxe légèrement mais le plus grand avantage (pour moi) c'est que vous n'avez pas besoin d'inclure quelque chose comme Boost pour obtenir bind. Mais si vous utilisez boost::threads vous pourriez aussi bien prendre boost::bind aussi. Remarque, C++ 11 a std::bind afin que vous pouvez utiliser bind avec pthreads ainsi et de ne pas adopter supplémentaire de la dépendance comme Boost, mais si vous voulez utiliser le C++ 11.

    Je ne vois pas convaincante syntaxe raison d'éviter l'utilisation bind d'avoir une méthode statique qui appelle des fonctions membres. Mais c'est plus une question de préférence personnelle.

    OriginalL'auteur tpg2114