Namespaces
Variants

Standard library header <exception>

From cppreference.net
C++
Standard library headers

Cet en-tête fait partie de la bibliothèque de gestion d'erreurs .

Table des matières

Types

classe de base pour les exceptions levées par les composants de la bibliothèque standard
(classe)
(C++11)
un type mixin pour capturer et stocker les exceptions courantes
(classe)
exception levée lorsque std::current_exception échoue à copier l'objet d'exception
(classe)
(obsolète en C++11) (supprimé en C++17)
le type de la fonction appelée par std::unexpected
(typedef)
le type de la fonction appelée par std::terminate
(typedef)
(C++11)
type de pointeur partagé pour la gestion des objets d'exception
(typedef)

Fonctions

(obsolète en C++11) (supprimé en C++17)
fonction appelée lorsque la spécification d'exception dynamique est violée
(fonction)
( removed in C++20* ) (C++17)
vérifie si la gestion d'exception est actuellement en cours
(fonction)
(C++11)
crée un std::exception_ptr à partir d'un objet exception
(fonction template)
(C++11)
capture l'exception actuelle dans un std::exception_ptr
(fonction)
(C++11)
lance l'exception depuis un std::exception_ptr
(fonction)
(C++11)
lance son argument avec std::nested_exception intégré
(modèle de fonction)
(C++11)
lance l'exception depuis un std::nested_exception
(fonction template)
fonction appelée lorsque la gestion des exceptions échoue
(fonction)
(C++11)
obtient le terminate_handler actuel
(fonction)
modifie la fonction à appeler par std::terminate
(fonction)
(obsolète en C++11) (supprimé en C++17)
obtient le unexpected_handler actuel
(fonction)
(obsolète en C++11) (supprimé en C++17)
modifie la fonction appelée par std::unexpected
(fonction)

Synopsis 

// tous freestanding
namespace std {
  class exception;
  class bad_exception;
  class nested_exception;
  using terminate_handler = void (*)();
  terminate_handler get_terminate() noexcept;
  terminate_handler set_terminate(terminate_handler f) noexcept;
  [[noreturn]] void terminate() noexcept;
  constexpr int uncaught_exceptions() noexcept;
  using exception_ptr = /* unspecified */;
  constexpr exception_ptr current_exception() noexcept;
  [[noreturn]] constexpr void rethrow_exception(exception_ptr p);
  template<class E> constexpr exception_ptr make_exception_ptr(E e) noexcept;
  template<class T> [[noreturn]] constexpr void throw_with_nested(T&& t);
  template<class E> constexpr void rethrow_if_nested(const E& e);
}

Classe std::exception 

namespace std {
  class exception
  {
  public:
    constexpr exception() noexcept;
    constexpr exception(const exception&) noexcept;
    constexpr exception& operator=(const exception&) noexcept;
    constexpr virtual ~exception();
    constexpr virtual const char* what() const noexcept;
  };
}

Classe std::bad_exception 

namespace std {
  class bad_exception : public exception
  {
  public:
    // voir la description pour la spécification des fonctions membres spéciales
    constexpr const char* what() const noexcept override;
  };
}

Classe std::nested_exception 

namespace std {
  class nested_exception
  {
  public:
    constexpr nested_exception() noexcept;
    constexpr nested_exception(const nested_exception&) noexcept = default;
    constexpr nested_exception& operator=(const nested_exception&) noexcept = default;
    constexpr virtual ~nested_exception() = default;
    // fonctions d'accès
    [[noreturn]] constexpr void rethrow_nested() const;
    constexpr exception_ptr nested_ptr() const noexcept;
  };
  template<class T> [[noreturn]] constexpr void throw_with_nested(T&& t);
  template<class E> constexpr void rethrow_if_nested(const E& e);
}

Voir aussi