Namespaces
Variants

std:: nested_exception

From cppreference.net
C++
Diagnostics library
Défini dans l'en-tête <exception>
class nested_exception ;
(depuis C++11)

std::nested_exception est une classe mixin polymorphe qui peut capturer et stocker l'exception actuelle, permettant ainsi d'imbriquer des exceptions de types arbitraires les unes dans les autres.

Toutes les fonctions membres de std::nested_exception sont constexpr .

(depuis C++26)

Table des matières

Fonctions membres

construit un nested_exception
(fonction membre publique)
[virtual]
détruit un nested exception
(fonction membre virtuelle publique)
remplace le contenu d'un nested_exception
(fonction membre publique)
lance l'exception stockée
(fonction membre publique)
obtient un pointeur vers l'exception stockée
(fonction membre publique)

Fonctions non membres

(C++11)
lance son argument avec std::nested_exception intégré
(modèle de fonction)
(C++11)
relance l'exception depuis une std::nested_exception
(modèle de fonction)

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_constexpr_exceptions 202411L (C++26) constexpr pour les types d'exception

Exemple

Démontre la construction et la récursion à travers un objet exception imbriqué.

Exécuter ce code 
#include <exception>
#include <fstream>
#include <iostream>
#include <stdexcept>
#include <string>
// prints the explanatory string of an exception. If the exception is nested,
// recurses to print the explanatory string of the exception it holds
void print_exception(const std::exception& e, int level =  0)
{
    std::cerr << std::string(level, ' ') << "exception: " << e.what() << '\n';
    try
    {
        std::rethrow_if_nested(e);
    }
    catch (const std::exception& nestedException)
    {
        print_exception(nestedException, level + 1);
    }
    catch (...) {}
}
// sample function that catches an exception and wraps it in a nested exception
void open_file(const std::string& s)
{
    try
    {
        std::ifstream file(s);
        file.exceptions(std::ios_base::failbit);
    }
    catch (...)
    {
        std::throw_with_nested(std::runtime_error("Couldn't open " + s));
    }
}
// sample function that catches an exception and wraps it in a nested exception
void run()
{
    try
    {
        open_file("nonexistent.file");
    }
    catch (...)
    {
        std::throw_with_nested(std::runtime_error("run() failed"));
    }
}
// runs the sample function above and prints the caught exception
int main()
{
    try
    {
        run();
    }
    catch (const std::exception& e)
    {
        print_exception(e);
    }
}

Sortie possible : 

exception: run() failed
 exception: Couldn't open nonexistent.file
  exception: basic_ios::clear

Voir aussi

(C++11)
type de pointeur partagé pour la gestion des objets d'exception
(typedef)
(C++11)
lance son argument avec std::nested_exception intégré
(function template)
(C++11)
lance l'exception depuis un std::nested_exception
(function template)