J'ai une classe de travailleurs comme celle ci-dessous:
Worker worker; boost::function<int()> th_func = boost::bind(&Worker::Do, &worker); boost::thread th(th_func); th.join();
5 Réponses :
Je ne pense pas que vous puissiez obtenir la valeur de retour.
à la place, vous pouvez stocker la valeur en tant que membre de travailleur: p> et utilisez-le comme Donc: P> Worker worker;
boost::function<void()> th_func = boost::bind(&Worker::Do, &worker);
boost::thread th(th_func);
th.join();
//do something with worker.m_ReturnValue
Merci, je suppose que je dois repenser un peu.
En outre, vous avez également des appels redondants à booster :: Bind () et boost :: Fonction (). Vous pouvez plutôt faire ce qui suit:
class Worker{
public:
void operator(){
int ret = 100;
// do stuff
m_ReturnValue = ret;
}
int m_ReturnValue;
}
Worker worker;
boost::thread th(worker());//or boost::thread th(boost::ref(worker));
Cela a l'air assez simple. Merci mais ma mise en œuvre réelle contient de nombreuses fonctions membres, je ne peux donc pas vraiment utiliser l'opérateur ().
@He Shiming: Vous pouvez toujours l'utiliser sans lier (). Par exemple, boost :: thread (travailleur () et ouvrier :: DO) (la syntaxe peut être légèrement éteinte depuis son sommet de ma tête).
Une autre option utilise le boost.lambda une bibliothèque. Ensuite, vous pouvez écrire le code comme suit sans modifier le Classe Code> Classe: Worker worker;
int ret;
boost::thread th( boost::lambda::var( ret ) = worker.Do() );
th.join();
Cela exécutera travailleur.do () dans le thread actuel, copiez le résultat dans un objet Lambda, exécutez-le en Lambda sur le nouveau thread (attribuant ainsi le résultat de travailleur.do () < / Code> à RET ), puis attendez que l'exécution du nouveau thread soit terminée. Ceci est très probablement pas le comportement souhaité, car il exécute travailleur.do () dans le mauvais fil. Le moyen le plus facile correct d'obtenir des résultats à partir d'une fonction exécutée dans un fil différent consiste à utiliser des contrats à terme et des promesses.
Une autre option consiste à utiliser des promesses / contrats à terme. et si vous pouvez utiliser c ++ 0x, puis utiliser std :: ASYNC emballera tout ce qui précède et tout simplement faire:
class Worker{
public:
int Do(){
int ret = 100;
// do stuff
return ret;
}
}
Worker worker;
boost::packaged_task<int> ptask(boost::bind(&Worker::Do, &worker));
boost::unique_future<int> future_int = ptask.get_future();
boost::thread th(boost::move(ptask));
th.join();
if (future_int.is_ready())
int return_value = future_int.get();
You can take a look at the "boost::future" concept, ref this link