Namespaces
Variants

std:: uncaught_exception, std:: uncaught_exceptions

From cppreference.net
C++
Diagnostics library
Défini dans l'en-tête <exception>
(1)
bool uncaught_exception ( ) throw ( ) ;
(jusqu'à C++11)
bool uncaught_exception ( ) noexcept ;
(depuis C++11)
(obsolète en C++17)
(supprimé en C++20)
int uncaught_exceptions ( ) noexcept ;
(2) (depuis C++17)
(constexpr depuis C++26)
1) Détecte si le thread courant possède un objet exception actif, c'est-à-dire qu'une exception a été levée ou relevée et n'est pas encore entrée dans une clause catch correspondante, std::terminate ou std::unexpected . En d'autres termes, std::uncaught_exception détecte si le déroulement de pile est actuellement en cours.
2) Détecte combien d'exceptions dans le thread actuel ont été levées ou relevées et n'ont pas encore atteint leurs clauses catch correspondantes.

Il est parfois sûr de lancer une exception même lorsque std :: uncaught_exception ( ) == true (jusqu'en C++17) std :: uncaught_exceptions ( ) > 0 (depuis C++17) . Par exemple, si le déroulement de pile provoque la destruction d'un objet, le destructeur de cet objet peut exécuter du code qui lance une exception tant que cette exception est capturée par un bloc catch avant de s'échapper du destructeur.

Table des matières

Paramètres

(aucun)

Valeur de retour

1) true si le déroulement de pile est actuellement en cours dans ce thread, false sinon.
2) Le nombre d'objets d'exception non capturés dans le thread actuel.

Notes

Un exemple où uncaught_exceptions retournant un int est utilisé est la bibliothèque boost.log : l'expression BOOST_LOG ( logger ) << foo ( ) ; crée d'abord un objet garde et enregistre le nombre d'exceptions non capturées dans son constructeur. La sortie est effectuée par le destructeur de l'objet garde sauf si foo ( ) lève une exception (auquel cas le nombre d'exceptions non capturées dans le destructeur est supérieur à ce que le constructeur a observé).

std::experimental::scope_fail et std::experimental::scope_success dans LFTS v3 reposent sur la fonctionnalité de uncaught_exceptions , car leurs destructeurs doivent effectuer des opérations différentes selon qu'ils sont appelés durant le déroulement de pile.

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_uncaught_exceptions 201411L (C++17) std::uncaught_exceptions
__cpp_lib_constexpr_exceptions 202411L (C++26) constexpr pour les types d'exception

Exemple

Exécuter ce code 
#include <exception>
#include <iostream>
#include <stdexcept>
struct Foo
{
    char id{'?'};
    int count = std::uncaught_exceptions();
    ~Foo()
    {
        count == std::uncaught_exceptions()
            ? std::cout << id << ".~Foo() called normally\n"
            : std::cout << id << ".~Foo() called during stack unwinding\n";
    }
};
int main()
{
    Foo f{'f'};
    try
    {
        Foo g{'g'};
        std::cout << "Exception thrown\n";
        throw std::runtime_error("test exception");
    }
    catch (const std::exception& e)
    {
        std::cout << "Exception caught: " << e.what() << '\n';
    }
}

Sortie possible : 

Exception thrown
g.~Foo() called during stack unwinding
Exception caught: test exception
f.~Foo() called normally

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR S'applique à Comportement publié Comportement corrigé
LWG 70 C++98 la spécification d'exception de uncaught_exception() était manquante spécifiée comme throw()

Voir aussi

fonction appelée lorsque la gestion des exceptions échoue
(fonction)
(C++11)
type de pointeur partagé pour manipuler les objets d'exception
(typedef)
(C++11)
capture l'exception courante dans un std::exception_ptr
(fonction)

Liens externes

1. GOTW numéro 47 : Exceptions non capturées
2. Justification de std::uncaught_exceptions (N4125)