Discussion :

[Baccs]

Bonjour,

je n'arrive pas à récupérer et relancer dans mon programme principal une exception levée et stockée dans un thread.
Le soucis vient du fait que j'ai plusieurs exceptions définies qui dérivent de la classe exception, et que j'aimerai bien récupérer celle du bon type.
Dans le cas qui m'intéresse, je lance une exception de type MyException.

Initialement, le thread stockait directement une variable de type exception, ce qui ne pouvait pas marchait me semble-t'il. (dans le code, c'est tout ce qui est exception2)
J'ai essayé de passer par un pointeur sur une exception, mais je perds tout de même le fait que mon exception est de type MyException et non pas de type exception.

Voila en très grossier le code que j'utilise :
3 classes impliquées : le programme principal, un pool de threads, et une classe thread.

Contenu grosso modo du Thread.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Thread 
{
public:
  Thread();
  virtual ~Thread();
  void run();
  exception* getException();
  exception& getException2();
  bool isThreadInException();
private:
  void handleException(exception& e);
  exception* _myException;
  exception  _myException2;
  bool _hasException;
};

Et le contenu grosso modo du Thread.cpp (je passe sur les constructeurs, destructeur etc...).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
bool Thread::isThreadInException()
{
  return _hasException;
}
 
exception* Thread::getException()
{
  return _myException;
}
 
exception& Thread::getException2()
{
  return _myException2;
}
 
void Thread::run ()
{
  _hasException = false;
  try {
    // do the job in a thread
  } catch (exception &e) {
    // Ici, un typeid(e) me renvoie MyException
    handleException(e);
  }
}
 
void Thread::handleException(exception& e)
{
  _hasException = true;
  _myException = &e;
  _myException2 = e;
  // Ici, un typeid(e) me renvoie MyException
  // un typeid(*_myException) me renvoie MyException
  // et un typeid(_myException2) me renvoie exception
  // jusque là c'est assez logique 
}

Contenu du ThreadPool.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class ThreadPool {
public:
  ThreadPool();
  virtual ~ThreadPool();
  bool hasOneTaskInException();
  exception* getException();
  exception& getException2();
protected:
  vector<Thread*> _threadTab;
  exception* _raisedException;
  exception  _raisedException2;
};

Contenu du ThreadPool.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
exception* ThreadPool::getException()
{
  return _raisedException;
}
 
exception& ThreadPool::getException2()
{
  return _raisedException2;
}
 
bool ThreadPool::hasOneTaskInException()
{
  bool hasException = false;
 
  for (t_UINT8 noThread = 0; noThread < _threadTab.size(); noThread++) {
    if (_threadTab[noThread]->isThreadInException()) {
      hasException = true;
      _raisedException = _threadTab[noThread]->getException();
      _raisedException2 = _threadTab[noThread]->getException2();
      // ici quelque soit le typeid :
      // typeid(*_threadTab[noThread]->getException())
      // typeid(_threadTab[noThread]->getException2())
      // typeid(*_raisedException)
      // typeid(_raisedException2)
      // cela me renvoie exception et non pas MyException
    }
  }
 
  return hasException;
}

Enfin le programme principal fait quelque chose du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
if (_threadPool->hasOneTaskInException())
{
  throw *(_threadPool->getException());
  // anciennement :
  // throw _threadPool->getException2();
}

C'est ici que je souhaiterais récupérer une exception de type MyException.

Auriez vous des idées pour faire cela proprement ?

Merci d'avance

[JolyLoic]

Je n'ai pas lu ton code, mais boost::exception, sorti depuis peu est prévu spécialement pour gérer la transmission d'exception inter-threads, en attendant la version du standard qui pourra faire la même chose (et dont s'est inspiré boost::exception).

[Baccs]

OK merci pour l'info.
Là mon problème se traduit par une anomalie mineure sur un code assez monstrueux qui n'utilise pas boost, du coup je ne vais pas pouvoir rajouter une dépendance comme boost, mais je pense que pour les prochains projets, je partirai la dessus !

[JolyLoic]

Je ne sais pas dans quelle mesure boost::exception est ou non indépendant du reste de boost. Mais dans le pire des cas, tu dois pouvoir t'inspirer de la manière dont ils ont fait.

[Alp]

Et sinon, il y a toujours l'outil bcp pour extraire un module de boost --- et ses dépendances biensûr --- afin de ne pas avoir à se trimballer boost dans sa totalité.

Pour en savoir plus : http://www.boost.org/doc/libs/1_36_0/tools/bcp/bcp.html