Espaces de noms
Variantes
Affichages
Actions

exception specification

De cppreference.com
< cpp‎ | language

 
 
Langage C++
Sujets généraux
Contrôle de flux
Instructions conditionnelles
Instructions d'itération
Instructions de saut
Fonctions
déclaration de fonction
expression lambda
fonction générique
spécificateur inline
spécification d'exception (obsolète)
spécificateur noexcept (C++11)
Exceptions
Espaces de noms
Types
spécificateur decltype (C++11)
Qualificatifs
qualificatifs const et volatile
qualificatifs de stockage
qualificatif constexpr (C++11)
qualificatif auto (C++11)
qualificatif alignas (C++11)
Initialisation
Littéraux
Expressions
opérateurs alternatifs
Utilitaires
Types
déclaration typedef
déclaration d'alias de type (C++11)
attributs (C++11)
Jette
Original:
Casts
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
conversions implicites
conversion const_cast
conversion static_cast
conversion dynamic_cast
conversion reinterpret_cast
conversions style C et style fonction
Allocation de mémoire
Classes
Qualificatifs spécifiques aux membres de classe
Fonctions membres spéciales
Modèles
classes génériques
fonctions génériques
spécialisation de modèles
paquets de paramètres (C++11)
Divers
Assembleur
 
Énumère les exceptions qu'une fonction peut directement ou indirectement jeter .
Original:
Lists the exceptions that a function might directly or indirectly throw.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Sommaire

[modifier] Syntaxe

throw(typeid, typeid, ...) (obsolète)

[modifier] Explication

Si une fonction est déclarée avec T type indiqué dans sa spécification d'exception, la fonction peut lever des exceptions de ce type ou un type dérivé de celle-ci .
Original:
If a function is declared with type T listed in its exception specification, the function may throw exceptions of that type or a type derived from it.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Si la fonction lève une exception de type ne figure pas dans sa spécification d'exception, le std::unexpected fonction est appelée. La fonction par défaut appelle std::terminate, mais il peut être remplacé par une fonction fournie par l'utilisateur (via std::set_unexpected) qui peut faire appel std::terminate ou lève une exception. Si les exceptions lancées depuis std::unexpected est acceptée par la spécification d'exception, empiler déroulement continue comme d'habitude. Si ce n'est pas le cas, mais std::bad_exception est autorisé par la spécification d'exception, std::bad_exception est levée. Sinon, std::terminate est appelé .
Original:
If the function throws an exception of the type not listed in its exception specification, the function std::unexpected is called. The default function calls std::terminate, but it may be replaced by a user-provided function (via std::set_unexpected) which may call std::terminate or throw an exception. If the exception thrown from std::unexpected is accepted by the exception specification, stack unwinding continues as usual. If it isn't, but std::bad_exception is allowed by the exception specification, std::bad_exception is thrown. Otherwise, std::terminate is called.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Exemple

class X {};
class Y {};
class Z : public X {};
class W {};
 
void f() throw(X, Y) 
{
    int n = 0;
    if (n) throw X(); // OK
    if (n) throw Z(); // also OK
    throw W(); // will call std::unexpected()
}


[modifier] Voir aussi