Doit-on dériver / hériter de std :: exception?

En concevant ma première bibliothèque C ++ «sérieuse», je me pose la question:

Est-ce un bon style de dériver ses exceptions std::exceptionet ses descendants?!

Même après avoir lu

• Conception de classes d'exception
• Qu'est-ce qu'un «bon nombre» d'exceptions à implémenter pour ma bibliothèque?

Je ne suis toujours pas sûr. Parce que, en plus des pratiques courantes (mais peut-être pas bonnes), je suppose, en tant qu'utilisateur de bibliothèque, qu'une fonction de bibliothèque ne lancerait std::exceptions que lorsque les fonctions de bibliothèque standard échouent dans l'implémentation de la bibliothèque, et elle ne peut rien y faire. Mais quand même, lors de l'écriture du code d'application, pour moi, c'est très pratique, et aussi à mon humble avis, il suffit de jeter un std::runtime_error. Mes utilisateurs peuvent également compter sur l'interface minimale définie, comme what()ou sur des codes.

Et par exemple, mon utilisateur fournit des arguments défectueux, quoi de plus pratique que de lancer un std::invalid_argument, n'est-ce pas? Donc, combiné avec l'utilisation encore courante de std :: exception, je vois dans le code d'autres: Pourquoi ne pas aller plus loin et dériver de votre classe d'exception personnalisée (par exemple lib_foo_exception) et aussi de std::exception.

Pensées?

Toutes les exceptions doivent hériter de std::exception.

Supposons, par exemple, que j'aie besoin d'appeler ComplexOperationThatCouldFailABunchOfWays()et que je souhaite gérer toutes les exceptions qu'il pourrait déclencher. Si tout hérite std::exception, c'est facile. Je n'ai besoin que d'un seul catchbloc, et j'ai une interface standard ( what()) pour obtenir des détails.

try {
    ComplexOperationThatCouldFailABunchOfWays();
} catch (std::exception& e) {
    cerr << e.what() << endl;
}

Si les exceptions n'héritent PAS de std::exception, cela devient beaucoup plus laid:

try {
    ComplexOperationThatCouldFailABunchOfWays();
} catch (std::exception& e) {
    cerr << e.what() << endl;
} catch (Exception& e) {
    cerr << e.Message << endl;
} catch (framework_exception& e) {
    cerr << e.Details() << endl;
}

En ce qui concerne l'opportunité de lancer runtime_errorou de invalid_argumentcréer vos propres std::exceptionsous-classes à lancer: Ma règle de base est d'introduire une nouvelle sous-classe chaque fois que j'ai besoin de traiter un type d'erreur particulier différemment des autres erreurs (c'est-à-dire chaque fois que j'ai besoin d'un catchbloc séparé ).

• Si j'introduis une nouvelle sous-classe d'exception pour chaque type d'erreur concevable, même si je n'ai pas besoin de les gérer séparément, cela ajoute beaucoup de prolifération de classe.
• Si je réutiliser les sous - classes existantes à moyenne quelque chose de spécifique ( par exemple, si un runtime_errorjeté ici signifie quelque chose de différent d'une erreur d'exécution générique), alors je risque d'entrer en conflit avec d' autres utilisations de la sous - classe existante.
• Si je n'ai pas besoin de gérer une erreur spécifiquement, et si l'erreur que je lance correspond exactement à l'une des erreurs de la bibliothèque standard existante (comme invalid_argument), alors je réutilise la classe existante. Je ne vois tout simplement pas beaucoup d'avantages à ajouter une nouvelle classe dans ce cas. (Les directives de base C ++ ne sont pas d'accord avec moi ici - elles recommandent toujours d'utiliser vos propres classes.)

Les directives de base C ++ contiennent d'autres discussions et exemples.

Je suppose, en tant qu'utilisateur de bibliothèque, qu'une fonction de bibliothèque ne lancerait std :: exceptions que lorsque les fonctions de bibliothèque standard ont échoué dans l'implémentation de la bibliothèque, et qu'elle ne peut rien y faire

C'est une hypothèse incorrecte.

Les types d'exceptions standard sont fournis pour une utilisation "plus courante". Ils ne sont pas conçus pour être utilisés uniquement par la bibliothèque standard.

Oui, faites tout hériter de tout std::exception. Souvent, cela impliquera l'héritage de std::runtime_errorou std::logic_error. Tout ce qui est approprié pour la classe d'exception que vous implémentez.

Ceci est bien sûr subjectif - plusieurs bibliothèques populaires ignorent complètement les types d'exceptions standard, vraisemblablement pour dissocier les bibliothèques de la bibliothèque standard. Personnellement, je pense que c'est extrêmement égoïste! Cela rend la capture d'exceptions beaucoup plus difficile à corriger.

En parlant personnellement, je lance souvent un std::runtime_erroret j'en ai fini avec. Mais c'est entrer dans une discussion sur la granularité de vos classes d'exception, ce qui n'est pas ce que vous demandez.