std:: current_exception

Si appelé pendant la gestion d'exception (typiquement, dans une catch clause), capture l'objet d'exception courant et crée un std::exception_ptr qui contient soit une copie soit une référence à cet objet d'exception (selon l'implémentation). L'objet référencé reste valide au moins tant qu'il existe un objet exception_ptr qui y fait référence.

Si l'implémentation de cette fonction nécessite un appel à new et que l'échec survient, le pointeur retourné contiendra une référence à une instance de std::bad_alloc .

Si la mise en œuvre de cette fonction nécessite la copie de l'objet d'exception capturé et que son constructeur de copie lève une exception, le pointeur retourné contiendra une référence à l'exception levée. Si le constructeur de copie de l'objet d'exception levé lève également une exception, le pointeur retourné peut contenir une référence à une instance de std::bad_exception pour rompre la boucle infinie.

Si la fonction est appelée lorsqu'aucune exception n'est en cours de traitement, un std::exception_ptr vide est retourné.

Cette fonction peut être appelée dans un std::terminate_handler pour récupérer l'exception qui a provoqué l'invocation de std::terminate .

Valeur de retour

Une instance de std::exception_ptr contenant une référence à l'objet d'exception, ou une copie de l'objet d'exception, ou vers une instance de std::bad_alloc ou vers une instance de std::bad_exception .

Notes

Sur les implémentations qui suivent Itanium C++ ABI (GCC, Clang, etc.), les exceptions sont allouées sur le tas lorsqu'elles sont levées (sauf pour std::bad_alloc dans certains cas), et cette fonction crée simplement le pointeur intelligent référençant l'objet précédemment alloué. Sur MSVC, les exceptions sont allouées sur la pile lorsqu'elles sont levées, et cette fonction effectue l'allocation sur le tas et copie l'objet d'exception.

Sur Windows dans les environnements CLR managés [1] , l'implémentation stockera un std::bad_exception lorsque l'exception actuelle est une exception managée ( [2] ). Notez que catch ( ... ) capture également les exceptions managées :

#include <exception>
int main()
{
    try
    {
        throw gcnew System::Exception("Managed exception");
    }
    catch (...)
    {
        std::exception_ptr ex = std::current_exception();
        try
        {
            std::rethrow_exception(ex);
        }
        catch (std::bad_exception const &)
        {
            // Ceci sera affiché.
            std::cout << "Bad exception" << std::endl;
        }
    }
}

Exemple

#include <exception>
#include <iostream>
#include <stdexcept>
#include <string>
void handle_eptr(std::exception_ptr eptr) // passing by value is OK
{
    try
    {
        if (eptr)
            std::rethrow_exception(eptr);
    }
    catch(const std::exception& e)
    {
        std::cout << "Caught exception: '" << e.what() << "'\n";
    }
}
int main()
{
    std::exception_ptr eptr;
    try
    {
        [[maybe_unused]]
        char ch = std::string().at(1); // this generates a std::out_of_range
    }
    catch(...)
    {
        eptr = std::current_exception(); // capture
    }
    handle_eptr(eptr);
} // destructor for std::out_of_range called here, when the eptr is destructed

Caught exception: 'basic_string::at: __n (which is 1) >= this->size() (which is 0)'

Voir aussi