lancer un nouveau std :: exception vs lancer std :: exception

en regardant du code, je suis tombé sur:

throw /*-->*/new std::exception ("//...

et j'ai toujours pensé que vous n'avez pas besoin / que vous ne devriez pas utiliser newici.
Quelle est la bonne manière, les deux sont-ils OK, si oui, y a-t-il une différence?

BTW d'après ce que je peux voir en "grepping" avec PowerShell, les bibliothèques boost ne l'utilisent jamais throw new.

PS aussi j'ai trouvé du code CLI qui utilise throw gcnew. Est-ce que ça va?

La manière conventionnelle de lancer et d'intercepter des exceptions est de lancer un objet d'exception et de l'attraper par référence (généralement constréférence). Le langage C ++ nécessite que le compilateur génère le code approprié pour construire l'objet d'exception et le nettoyer correctement au moment opportun.

Lancer un pointeur vers un objet alloué dynamiquement n'est jamais une bonne idée. Les exceptions sont censées vous permettre d'écrire du code plus robuste face aux conditions d'erreur. Si vous lancez un objet d'exception de la manière conventionnelle, vous pouvez être sûr que s'il est intercepté par une clause catch nommant le type correct, par un catch (...), s'il est ensuite relancé ou non, il sera détruit correctement au moment approprié. (La seule exception étant si elle n'est jamais interceptée du tout mais c'est une situation irrécupérable quelle que soit la façon dont vous la regardez.)

Si vous lancez un pointeur vers un objet alloué dynamiquement, vous devez être sûr que quel que soit l'aspect de la pile d'appels au moment où vous souhaitez lever votre exception, il existe un bloc catch qui nomme le type de pointeur correct et a l' deleteappel approprié . Votre exception ne doit jamais être interceptée à catch (...)moins que ce bloc ne relance l'exception qui est ensuite interceptée par un autre bloc catch qui traite correctement l'exception.

En fait, cela signifie que vous avez utilisé la fonction de gestion des exceptions qui devrait faciliter l'écriture de code robuste et rendu très difficile l'écriture de code correct dans toutes les situations. Cela laisse de côté le problème qu'il sera presque impossible d'agir en tant que code de bibliothèque pour le code client qui n'attendra pas cette fonctionnalité.

Pas besoin d'utiliser newlors de la levée d'exception.

Ecrivez:

throw yourexception(yourmessage);

et attraper comme:

catch(yourexception const & e)
{
      //your code (probably logging related code)
}

Notez que cela yourexceptiondoit dériver std::exceptiondirectement ou indirectement.

Le lancement new std::exceptionest correct si le site d'appel s'attend à attraper un fichier std::exception*. Mais personne ne s'attendra à attraper un pointeur vers une exception. Même si vous documentez ce que fait votre fonction et que les gens lisent la documentation, ils sont toujours susceptibles d'oublier et d'essayer d'attraper une référence à un std::exceptionobjet à la place.

La FAQ C ++ a une belle discussion à ce sujet:

1. https://isocpp.org/wiki/faq/exceptions#what-to-catch
2. https://isocpp.org/wiki/faq/exceptions#catch-by-ptr-in-mfc

Fondamentalement, "à moins qu'il n'y ait une bonne raison de ne pas le faire, attraper par référence. Évitez d'attraper par valeur, car cela entraîne une copie et la copie peut avoir un comportement différent de celui qui a été lancé. Ce n'est que dans des circonstances très spéciales que vous devez attraper par pointeur. "

L'opérateur new ne peut garantir qu'il ne déclenchera jamais d'exception. Pour cette raison, l'utiliser pour lancer une exception "valide" (intentionnelle) produirait un code dont on ne peut garantir qu'il ne plantera pas. Puisqu'il ne peut y avoir qu'une seule exception à la fois et que votre programme essaie d'en lancer deux avant qu'aucune d'entre elles ne puisse être interceptée, la meilleure chose qu'une implémentation puisse faire est d'abandonner immédiatement votre programme, par exemple en appelant std :: terminate.