Partager via

fonctions<exception>

  • Article

current_exception

Obtient un pointeur intelligent vers l'exception actuelle.

exception_ptr current_exception();

Valeur de retour

Objet exception_ptr qui pointe vers l’exception actuelle.

Notes

Appelez la fonction current_exception dans un bloc catch. Si une exception a été levée et si le bloc catch peut l'intercepter, la fonction current_exception retourne un objet exception_ptr qui référence l'exception. Sinon, la fonction retourne un objet exception_ptr null.

La fonction current_exception capture l’exception en vol même si l’instruction catch spécifie une instruction exception-declaration.

Le destructeur de l'exception actuelle est appelé à la fin du bloc catch si vous n'avez pas levé à nouveau l'exception. Toutefois, même si vous appelez la fonction current_exception dans le destructeur, celle-ci retourne un objet exception_ptr qui référence l’exception actuelle.

Les appels successifs à la fonction current_exception retournent des objets exception_ptr qui font référence à des copies de l'exception actuelle. Par conséquent, les objets sont considérés comme inégaux car ils font référence à des copies, bien que les copies aient la même valeur binaire.

make_exception_ptr

Crée un objet exception_ptr qui contient une copie d’une exception.

template <class E>
    exception_ptr make_exception_ptr(E Except);

Paramètres

Except
Classe avec l'exception à copier. Généralement, vous spécifiez un objet de classe exception comme argument pour la fonction make_exception_ptr, bien que tout objet de classe puisse être l’argument.

Valeur de retour

Objet exception_ptr pointant vers une copie de l’exception actuelle pour Except.

Notes

L’appel de la fonction make_exception_ptr équivaut à lever une exception C++, à l’intercepter dans un bloc catch, puis à appeler la fonction current_exception pour retourner un objet exception_ptr qui référence l’exception. L'implémentation Microsoft de la fonction make_exception_ptr est plus efficace que le fait de lever puis d'intercepter une exception.

En général, une application ne requiert pas la fonction make_exception_ptr, et son utilisation est d'ailleurs déconseillée.

rethrow_exception

Lève une exception passée comme paramètre.

void rethrow_exception(exception_ptr P);

Paramètres

P
L'exception interceptée à lever de nouveau. Si P est une exception_ptr Null, la fonction lève std ::bad_exception.

Notes

Après avoir enregistré une exception interceptée dans un objet exception_ptr, le thread principal peut traiter l'objet. Dans votre thread principal, appelez la fonction rethrow_exception avec l'objet exception_ptr en tant qu'argument. La fonction rethrow_exception extrait l'exception de l'objet exception_ptr puis lève l'exception dans le contexte du thread principal.

get_terminate

Obtient la fonction terminate_handler actuelle.

terminate_handler get_terminate();

set_terminate

Génère un nouvel appel à terminate_handler à l'arrêt du programme.

terminate_handler set_terminate(terminate_handler fnew) throw();

Paramètres

fnew
La fonction doit être appelée à la fin.

Valeur de retour

Adresse de la fonction précédente utilisée à appeler à la fin.

Notes

La fonction établit une nouvelle terminate_handler comme fonction * fnew. Par conséquent, fnew ne doit pas être un pointeur Null. La fonction retourne l’adresse du gestionnaire d’arrêt précédent.

Exemple

// exception_set_terminate.cpp
// compile with: /EHsc
#include <exception>
#include <iostream>

using namespace std;

void termfunction()
{
    cout << "My terminate function called." << endl;
    abort();
}

int main()
{
    terminate_handler oldHandler = set_terminate(termfunction);

    // Throwing an unhandled exception would also terminate the program
    // or we could explicitly call terminate();

    //throw bad_alloc();
    terminate();
}

get_unexpected

Obtient la fonction unexpected_handler actuelle.

unexpected_handler get_unexpected();

rethrow_if_nested

template <class E>
    void rethrow_if_nested(const E& e);

Notes

Si ce n’est pas un type de classe polymorphe, ou s’il nested_exception est inaccessible ou ambigu, il n’y a aucun effet. Sinon, effectue un cast dynamique.

set_unexpected

Génère un nouveau unexpected_handler à appeler en cas d'exception inattendue.

unexpected_handler set_unexpected(unexpected_handler fnew) throw();

Paramètres

fnew
Fonction à appeler en cas d’exception inattendue.

Valeur de retour

Adresse du unexpected_handler précédent.

Notes

fnew ne doit pas être un pointeur Null.

La norme C++ nécessite l’appel de unexpected quand une fonction lève une exception qui n’est pas dans sa liste d’exceptions à lever. L’implémentation actuelle ne le prend pas en charge. L’exemple suivant appelle unexpected directement, qui appelle ensuite le unexpected_handler.

Exemple

// exception_set_unexpected.cpp
// compile with: /EHsc
#include <exception>
#include <iostream>

using namespace std;

void uefunction()
{
    cout << "My unhandled exception function called." << endl;
    terminate(); // this is what unexpected() calls by default
}

int main()
{
    unexpected_handler oldHandler = set_unexpected(uefunction);

    unexpected(); // library function to force calling the
                  // current unexpected handler
}

terminate

Appelle un gestionnaire d'arrêt.

void terminate();

Notes

La fonction appelle un gestionnaire d’arrêt, une fonction de type void. S’il terminate est appelé directement par le programme, le gestionnaire d’arrêt est celui qui est le plus récemment défini par un appel à set_terminate. Si terminate elle est appelée pour plusieurs autres raisons lors de l’évaluation d’une expression levée, le gestionnaire d’arrêt est celui en vigueur immédiatement après l’évaluation de l’expression levée.

Un gestionnaire d’arrêt ne peut pas retourner à son appelant. Au démarrage du programme, le gestionnaire d’arrêt est une fonction qui appelle abort.

Exemple

Consultez set_unexpected pour obtenir un exemple d’utilisation de terminate.

throw_with_nested

template <class T> [[noreturn]]
    void throw_with_nested(T&& t);

Notes

Lève une exception avec des exceptions imbriquées.

uncaught_exception

Retourne true uniquement si une exception levée est actuellement traitée.

bool uncaught_exception();

Valeur de retour

Retourne true à la fin de l’évaluation d’une expression throw et avant la fin de l’initialisation de la déclaration d’exception dans le gestionnaire correspondant, ou en appelant unexpected suite à l’expression throw. En particulier, uncaught_exception retourne true quand elle est appelée à partir d’un destructeur lui-même appelé pendant le déroulement d’une exception. Concernant les appareils, uncaught_exception est uniquement pris en charge sur Windows CE 5.00 et versions supérieures, notamment les plateformes Windows Mobile 2005.

Exemple

// exception_uncaught_exception.cpp
// compile with: /EHsc
#include <exception>
#include <iostream>
#include <string>

class Test
{
public:
   Test( std::string msg ) : m_msg( msg )
   {
      std::cout << "In Test::Test(\"" << m_msg << "\")" << std::endl;
   }
   ~Test( )
   {
      std::cout << "In Test::~Test(\"" << m_msg << "\")" << std::endl
         << "        std::uncaught_exception( ) = "
         << std::uncaught_exception( )
         << std::endl;
   }
private:
    std::string m_msg;
};

// uncaught_exception will be true in the destructor
// for the object created inside the try block because
// the destructor is being called as part of the unwind.

int main( void )
   {
      Test t1( "outside try block" );
      try
      {
         Test t2( "inside try block" );
         throw 1;
      }
      catch (...) {
   }
}

In Test::Test("outside try block")
In Test::Test("inside try block")
In Test::~Test("inside try block")
        std::uncaught_exception( ) = 1
In Test::~Test("outside try block")
        std::uncaught_exception( ) = 0

inattendu

Appelle le gestionnaire d’exceptions inattendues.

void unexpected();

Notes

La norme C++ nécessite l’appel de unexpected quand une fonction lève une exception qui n’est pas dans sa liste d’exceptions à lever. L’implémentation actuelle ne le prend pas en charge. L’exemple appelle unexpected directement, qui appelle le gestionnaire d’exceptions inattendues.

La fonction appelle un gestionnaire d’exceptions inattendues, une fonction de type void. Si le programme appelle directement unexpected, le gestionnaire d’exceptions inattendues est le dernier défini par un appel à set_unexpected.

Un gestionnaire d’exceptions inattendues ne peut pas retourner à son appelant. Il peut mettre fin à l’exécution en effectuant l’une des opérations suivantes :

  • Levée d’un objet d’un type répertorié dans la spécification d’exception ou d’un objet de n’importe quel type, si le programme appelle directement le gestionnaire d’exceptions inattendues.

  • Levée d’un objet de type bad_exception.

  • Appel de fin, abort ou exit.

Au démarrage du programme, le gestionnaire d’exceptions inattendues est une fonction qui appelle terminate.

Exemple

Consultez set_unexpected pour obtenir un exemple d’utilisation de unexpected.