Discussion :

[Aleph69]

Bonjour à tous,

je me documente en ce moment sur les exceptions et je viens de découvrir qu'il est possible d'indiquer quel type d'exception est lancé par une fonction :

Code :

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

1
2
3
int fonction(int param) throw(); // aucune exception autorisée
int fonction(int param) throw(int) // seules les exceptions de type int autorisées
int fonction(int param); // tous les types d'exceptions autorisés

Que gagne-t-on à spécifier les types d'exception?

[Klaim]

Au final, rien, sauf dans le cas de throw() ou potentiellement le compilateur peut faire quelques optimizations, mais c'est pas garanti;

Du coup c'est devenu deprecated dans C++11 mais il y a une nouvelle instruction, nothrow (qui est un raccourci pour nothrow(...) ) qui n'a pas exactement la même sémantique mais devrait être plus utile.

On utilise nothrow quand on veut que le compilateur ne fasse rien pour gérer les exceptions dans la fonction marquée. Par contre si il y a une exception lancée, ca déclenche un appel direct a terminate().

Cela dit je pense qu'un expert pourra être plus précis sur le sujet, c'est assez compliqué.

Si tu veux savoir quand utiliser nothrow ou autres, c'est simple: ne les utilise pas sauf si :
1. tu bosses sur une bibliothèque standard ou de boost
2. tu veux définir un destructeur qui fait pas mal de boulot (normalement les destructeurs sont nothrow dans C++11 par défaut mais si t'en déclare un il ne l'est plus sauf si tu le marques mais généralement ce n'est pas très grave de l'oublier)

Je pense qu'il y a d'autres cas mais je ne les connais pas d'experience.

[Aleph69]

Salut Klaim,

merci pour ta réponse. Il faut vraiment que je me mette à jour concernant la nouvelle norme. Connais-tu un document listant toutes les nouveautés et dépréciations?

Quelle est cette instruction nothrow? S'agit-il de celle-ci?
http://www.cplusplus.com/reference/std/new/nothrow/
Apparemment, il s'agit simplement d'un type (nothrow_t) mais l'idée est assez ingénieuse. Cela se généralise-t-il à d'autres opérateurs que new?

[Aleph69]

Je pense qu'il y a d'autres cas mais je ne les connais pas d'experience.

Apparemment, il y a un corollaire à ton point 2 : lorsqu'une fonction est appelée dans un destructeur, elle ne devrait pas lever d'exception et ceci pourrait être spécifié par le développeur.

Sinon, je suis tombé sur un autre mot-clé, noexcept :
http://en.cppreference.com/w/cpp/language/noexcept
Ce n'est pas plutôt de cela dont tu parles dans ton premier message?

[Flob90]

Un destructeur qui peut lancer c'est un très gros risque. Si il lance pendant un stack unwinding (l'étape de destructeur des objets à portée automatique en sortie d'un bloc try), alors ton programme va terminer (std::terminate).

Une solution pour contourner ce problème c'est de mettre des swallow exceptions dans les destructeurs. C'et à dire des bloc try avec un catch(...) vide.

Cette technique fait perdre l'excpetion lancée, cependant c'est une perte à relativiser étant donné qu'elle se produit lorsque l'on décide de ne plus utiliser la ressource, et qu'un nouvelle exception pourra être levé à la prochaine utilisation de la ressource si besoin.

Un compromis pour laisser la posibilité à l'utilisateur de traiter les exceptions qui peuvent être lancer à la destruction, est de leur fournir explicitement une fonction free/close/unload/clean à appeler dans ce but.

Ca demande un effort supplémentairede la part de l'utilisateur (par rapport à une situation normal où le RAII fait tout le travail), dissons que c'est le prix à payer pour utiliser des ressources complexes.

Une autre solution (qui demande aussi un effort à l'utilisateur), est d'écrire l'ensemble des éléments du destructeurs qui peuvent lancer dans une fonction, et de délégueur l'appel de cette fonction à un foncteur interne à l'objet qui devra gérer les exceptions. Ainsi on peut laisser la possibilité à l'utilisateur de définir les traitement à effectuer en cas d'exceptions.

En combinant les deux :

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
 
strcut A
{
  std::function<void (std::function<void ()>)> treat_excpetions;
  void free()
  { /*code qui peut lancer*/ }
  A() :
  template<class F>
  A(F f) : treat_exceptions(f) {}
  ~A()
  {
    /*code qui ne lance pas*/
    try
    { 
      if(treat_exception) 
        treat_exceptions(std::bind(&A::free,this));
      else free();
    }
    catch(...)
    { }
  }
};
 
void my_treatment(std::function<void> f)
{
  try { f(); }
  catch(const E1&) { /*code*/ }
  catch(const E2&) { /*code*/ }
}

[jblecanard]

Bonne technique Flob mais ça reste rare d'en avoir besoin, normalement.