Voir la source de cpp/language/throw

Vous n’avez pas le droit de modifier cette page, pour la raison suivante :
L’action que vous essayez de réaliser n’est permise qu’aux utilisateurs d’un des groupes : Utilisateurs, Administrateurs.
Vous pouvez voir et copier le contenu de cette page.
{{tr_note}}
{{title|throw expression}}
{{cpp/language/navbar}}
{{tr|Indique une condition d'erreur et exécute un gestionnaire d'erreur .|Signals an erroneous condition and executes an error handler.}}

===Syntaxe===
{{sdsc begin}}
{{sdsc | num=1 | {{ttb|throw}} {{spar|expression}} }}
{{sdsc | num=2 | {{ttb|throw}} }}
{{sdsc end}}

===Explication===
:{{small|{{tr|Voir {{rlp|try_catch |{{tr| bloc try-catch| try-catch block}}}} pour plus d'informations à propos de'' essayer'' et'''' capture (gestionnaire d'exception) blocs|See {{rlp|try_catch |{{tr| bloc try-catch| try-catch block}}}} for more information about ''try'' and ''catch'' (exception handler) blocks}}}}

1) {{tr|L'expression jet construit un objet temporaire de stockage spécifié, avec le même type que {{tt|expression}} (avec CV-qualificatifs éliminé et le type de tableau de conversion de pointeur pour T T et T de la fonction de retour à un pointeur de fonction de retour T, au besoin) , et l'initialise à partir {{spar|expression}} de la même manière un les arguments des fonctions ou valeurs de retour sont initialisées à partir des paramètres de la fonction ou de l'argument d'une expression {{c|return}} (c.-copie élision et la construction déménagement aura lieu si possible). L'objet exception persiste jusqu'à ce que la clause catch dernière se termine ou jusqu'à ce que le dernier {{lc|std::exception_ptr}} qui fait référence à cet objet est détruit .|The throw expression constructs a temporary object in unspecified storage, with the same type as {{tt|expression}} (with cv-qualifiers removed and the type converted from array of T to pointer to T and from function returning T to pointer to function returning T, as necessary), and initializes it from {{spar|expression}} in the same manner a function arguments or return values are initialized from the function parameters or the argument of a {{c|return}} expression (i.e. copy elision and move construction take place if possible). The exception object persists until the last catch clause completes or until the last {{lc|std::exception_ptr}} that references this object is destroyed.}}

{{tr|Une fois l'objet exception est construit, le flux de contrôle fonctionne à l'envers (la pile des appels) jusqu'à ce qu'il atteigne le début d'un bloc {{tt|try}}, à quel point les paramètres des blocs {{tt|catch}} associés sont comparées à la {{spar|expression}} lancé pour trouver une correspondance. Si aucune correspondance n'est trouvée, le flux de contrôle continue à détendre la pile jusqu'à ce que le bloc {{tt|try}} suivante, et ainsi de suite. Si une correspondance est trouvée, les sauts de flux de contrôle passe au bloc {{tt|catch}} correspondant (le gestionnaire d'exception''''), qui s'exécute normalement .|Once the exception object is constructed, the control flow works backwards (up the call stack) until it reaches the start of a {{tt|try}} block, at which point the parameters of the associated {{tt|catch}} blocks are compared with the thrown {{spar|expression}} to find a match. If no match is found, the control flow continues to unwind the stack until the next {{tt|try}} block, and so on. If a match is found, the control flow jumps to the matching {{tt|catch}} block (the ''exception handler''), which executes normally.}}

{{tr|Comme le flux de contrôle déplace la pile des appels, les destructeurs sont appelés pour tous les objets avec «{{rlp|storage_duration |{{tr|durée de stockage automatique|automatic storage duration}}}}'' construit depuis le corrélatif try-block a été conclu, dans l'ordre inverse de la construction. Si une exception est levée à partir d'un constructeur, les destructeurs sont appelés pour toutes entièrement construits non statiques non-membres de variantes et classes de base. Ce processus est appelé'''' pile dénouement .|As the control flow moves up the call stack, destructors are invoked for all objects with '{{rlp|storage_duration |{{tr|durée de stockage automatique|automatic storage duration}}}}'' constructed since the corresponding try-block was entered, in reverse order of construction. If an exception is thrown from a  constructor, destructors are called for all fully-constructed non-static non-variant members and base classes. This process is called ''stack unwinding''.}}

2) {{tr|La remise expression sans un opérande ne peut être utilisé à l'intérieur d'un bloc catch (il appelle {{lc|std::terminate}} si utilisée). Il abandonne l'exécution du bloc catch et passe le contrôle à la clause catch correspondant suivant la pile des appels (mais pas à un autre clause catch après le même bloc try), la réutilisation de l'objet exception existante: pas de nouveaux objets sont faits .|The throw-expression without an operand may only be used inside a catch block (it calls {{lc|std::terminate}} if used otherwise). It abandons the execution of the catch block and passes control to the next matching catch clause up the call stack (but not to another catch clause after the same try block), reusing the existing exception object: no new objects are made.}}

{{tr|Voir {{lc|std::terminate}} et {{lc|std::unexpected}} pour la gestion des erreurs qui surviennent pendant le traitement des exceptions .|See {{lc|std::terminate}} and {{lc|std::unexpected}} for the handling of errors that arise during exception handling.}}
 
===D'utilisation===
{{tr|Bien throw-expression peut être utilisée pour transférer le contrôle à un bloc de code arbitraire jusqu'à la pile d'exécution, pour des raisons arbitraires (similaire à {{lc|std::longjmp}}), son utilisation prévue est la gestion des erreurs . |While throw-expression can be used to transfer control to an arbitrary block of code up the execution stack, for arbitrary reasons (similar to {{lc|std::longjmp}}), its intended usage is error handling. }}

====Erreur de manipulation====
{{tr|Lancer une exception est utilisé pour signaler les erreurs de fonctions, où les «erreurs» sont généralement limités à seulement ce qui suit <ref> Sutter H. (2004) [http://www.drdobbs.com/when-and-how-to-use-exceptions/184401836 "When and How to Use Exceptions"] dans Dr. Dobb a </ ref> H.Sutter <ref>, A. Alexandrescu (2004), "C + + Coding Standards", point 70 </ ref>:|Throwing an exception is used to signal errors from functions, where "errors" are typically limited to only the following<ref> H. Sutter (2004) [http://www.drdobbs.com/when-and-how-to-use-exceptions/184401836 "When and How to Use Exceptions"] in Dr. Dobb's</ref><ref>H.Sutter, A. Alexandrescu (2004), "C++ Coding Standards", Item 70</ref>:}}
{{tr|# Défaillances d'établir des invariants |# Failures to establish invariants }}
{{tr|# Incapacité de régler les postconditions|# Failures to meet the postconditions}}
{{tr|# Manquements aux conditions de l'appelant|# Failures to meet the preconditions of the caller}}

{{tr|En particulier, cela implique que les défaillances des constructeurs et la plupart des opérateurs doivent être déclarés en lançant des exceptions .|In particular, this implies that the failures of constructors and most operators should be reported by throwing exceptions.}}

====Exception de sécurité====
{{tr|Après que la condition d'erreur est signalé par une fonction, des garanties supplémentaires peuvent être prévues en ce qui concerne l'état du programme. Les quatre niveaux de garantie exception sont généralement reconnus B. <ref> Stroustrup (2000), "Le C + + Programming Language" [http://www2.research.att.com/~bs/3rd_safe.pdf Appendix E"] </ ref> <ref> H. Sutter (2000) "Exceptional C + +" </ ref> <ref> D. Abrahams (2001) [http://www.boost.org/community/exception_safety.html "Exception Safety in Generic Components"] </ ref>, qui sont supersets strictes de l'autre:|After the error condition is reported by a function, additional guarantees may be provided with regards to the state of the program. The following four levels of exception guarantee are generally recognized<ref>B. Stroustrup (2000), "The C++ Programming Language"[http://www2.research.att.com/~bs/3rd_safe.pdf Appendix E"]</ref><ref>H. Sutter (2000) "Exceptional C++"</ref><ref>D. Abrahams (2001) [http://www.boost.org/community/exception_safety.html "Exception Safety in Generic Components"]</ref>, which are strict supersets of each other:}}

{{tr|#'' Nothrow (ou nofail) garantie exception'' - la fonction ne lève jamais les exceptions .|# ''Nothrow (or nofail) exception guarantee'' -- the function never throws exceptions.}}
{{tr|#'' Garantie'' exception Forte - Si la fonction lève une exception, l'état du programme est restaurée à l'état juste avant l'appel de fonction .|# ''Strong exception guarantee'' -- If the function throws an exception, the state of the program is rolled back to the state just before the function call.}}
{{tr|#'' Garantie'' exception Basic - Si la fonction lève une exception, le programme est dans un état valide. Il peut exiger de nettoyage, mais tous les invariants sont intacts .|# ''Basic exception guarantee'' -- If the function throws an exception, the program is in a valid state. It may require cleanup, but all invariants are intact.}}
{{tr|#'' Aucune garantie exception'' - Si la fonction lève une exception, le programme peut ne pas être dans un état valide: fuites de ressources, la corruption de la mémoire, ou d'autres invariants qui détruisent des erreurs ont pu se produire .|# ''No exception guarantee'' -- If the function throws an exception, the program may not be in a valid state: resource leaks, memory corruption, or other invariant-destroying errors may have occurred.}}

===Objets d'exception===
{{tr|Alors que les objets de toute nature complète et des pointeurs cv à vide peut être jeté comme des objets d'exception, toutes les fonctions de la bibliothèque standard jeter anonymes objets temporaires en valeur, et les types de ces objets sont issus (directement ou indirectement) de {{lc|std::exception}}. Exceptions définies par l'utilisateur suivent généralement ce processus. <ref> D. Abrahams (2001) [http://www.boost.org/community/error_handling.html "Error and Exception Handling"] </ ref> <ref> M. Cline, C + + FAQ Lite [http://www.parashift.com/c++-faq-lite/exceptions.html#faq-17.11 17.11] </ ref>|While objects of any complete type and cv pointers to void may be thrown as exception objects, all standard library functions throw anonymous temporary objects by value, and the types of those objects are derived (directly or indirectly) from {{lc|std::exception}}. User-defined exceptions usually follow this pattern.<ref>D. Abrahams (2001) [http://www.boost.org/community/error_handling.html "Error and Exception Handling"]</ref><ref>M. Cline, C++FAQ Lite [http://www.parashift.com/c++-faq-lite/exceptions.html#faq-17.11 17.11]</ref>}}

{{tr|Pour éviter la copie inutile de l'objet exception et l'objet à trancher, la meilleure pratique pour les clauses de prises est d'attraper par référence. <ref> S. Meyers (1996) "Plus Effective C + +" Article 13 </ ref> <ref> M. Cline, C + + FAQ Lite [http://www.parashift.com/c++-faq-lite/exceptions.html#faq-17.12 17.12] </ ref> H.Sutter <ref>, A. Alexandrescu (2004) "C + + Coding Standards" Article 73 </ ref>|To avoid unnecessary copying of the exception object and object slicing, the best practice for catch clauses is to catch by reference.<ref>S. Meyers (1996) "More Effective C++" Item 13</ref><ref>M. Cline, C++FAQ Lite [http://www.parashift.com/c++-faq-lite/exceptions.html#faq-17.12 17.12]</ref><ref>H.Sutter, A. Alexandrescu (2004) "C++ Coding Standards" Item 73</ref>}}

===Mots-clés===
{{ltt|cpp/keyword/throw}}

===Exemple===
{{todo}}

===Références===
{{tr|<references/>|<references/>}}

===Voir aussi===
* {{rlp|try_catch |{{tr| bloc try-catch| try-catch block}}}}
* {{rlp|noexcept_spec |{{tr| noexcept spécificateur| noexcept specifier}}}}
* {{rlp|except_spec |{{tr| spécifications d'exception| exception specifications}}}}

[[de:cpp/language/throw]]
[[en:cpp/language/throw]]
[[es:cpp/language/throw]]
[[it:cpp/language/throw]]
[[ja:cpp/language/throw]]
[[pt:cpp/language/throw]]
[[ru:cpp/language/throw]]
[[zh:cpp/language/throw]]
Modèles utilisés par cette page :
Revenir à la page cpp/language/throw.
cppreference.com

Rechercher

Espaces de noms

Variantes

Affichages

Actions

Voir la source de cpp/language/throw

Navigation

Outils
