Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/error/throw with nested"

From cppreference.com
< cpp‎ | error
m (c++11 of course)
m (fmt, ., langlinks)
 
(16 intermediate revisions by 4 users not shown)
Line 1: Line 1:
 
{{cpp/title|throw_with_nested}}
 
{{cpp/title|throw_with_nested}}
−
{{cpp/error/sidebar}}
+
{{cpp/error/navbar}}
  
−
{{ddcl | header=exception | notes={{mark since c++11}} |
+
{{ddcl|header=exception|since=c++11|
 
template< class T >
 
template< class T >
 
[[noreturn]] void throw_with_nested( T&& t );
 
[[noreturn]] void throw_with_nested( T&& t );
 
}}
 
}}
  
−
Throws an exception of unspecified type that is derived from both {{cpp|std::nested_exception}} and from {{cpp|std::remove_reference<T>::type}}, and constructed from {{cpp|std::forward<T>(t)}}.
+
If {{c|std::decay<T>::type}} is a non-final non-union class type that is neither {{lc|std::nested_exception}} nor derived from {{lc|std::nested_exception}}, throws an exception of an unspecified type that is publicly derived from both {{lc|std::nested_exception}} and from {{c|std::decay<T>::type}}, and constructed from {{c|std::forward<T>(t)}}. The default constructor of the {{tt|nested_exception}} base class calls {{lc|std::current_exception}}, capturing the currently handled exception object, if any, in a {{lc|std::exception_ptr}}.  
  
−
If {{cpp|std::remove_reference<T>::type}} is already derived from {{cpp|std::nested_exception}}, simply throws {{cpp|std::forward<T>(t)}}.
+
Otherwise, throws {{c|std::forward<T>(t)}}.
  
−
Requires that {{cpp|std::remove_reference<T>::type}} is {{concept|CopyConstructible}}
+
Requires that {{c|std::decay<T>::type}} is {{named req|CopyConstructible}}.
  
 
===Parameters===
 
===Parameters===
−
{{param list begin}}
+
{{par begin}}
−
{{param list item | t | the exception object to throw}}
+
{{par|t|the exception object to throw}}
−
{{param list end}}
+
{{par end}}
  
 
===Return value===
 
===Return value===
−
 
 
(none)
 
(none)
  
−
{{cpp/error/exception/nested_exception_example}}
+
===Example===
 +
{{include|cpp/error/example_nested_exception}}
  
 
===See also===
 
===See also===
−
{{dcl list begin}}
+
{{dsc begin}}
−
{{dcl list template | cpp/error/exception/dcl list nested_exception}}
+
{{dsc inc|cpp/error/dsc nested_exception}}
−
{{dcl list template | cpp/error/exception/dcl list rethrow_if_nested}}
+
{{dsc inc|cpp/error/dsc rethrow_if_nested}}
−
{{dcl list end}}
+
{{dsc end}}
 +
 
 +
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}

Latest revision as of 09:27, 1 September 2023

 
C++
 
Diagnostics library
 
Defined in header <exception>
template< class T >
[[noreturn]] void throw_with_nested( T&& t );
 (since C++11)

If std::decay<T>::type is a non-final non-union class type that is neither std::nested_exception nor derived from std::nested_exception, throws an exception of an unspecified type that is publicly derived from both std::nested_exception and from std::decay<T>::type, and constructed from std::forward<T>(t). The default constructor of the nested_exception base class calls std::current_exception, capturing the currently handled exception object, if any, in a std::exception_ptr.

Otherwise, throws std::forward<T>(t).

Requires that std::decay<T>::type is CopyConstructible.

Contents

[edit] Parameters

t - the exception object to throw

[edit] Return value

(none)

[edit] Example

[edit]

Demonstrates construction and recursion through a nested exception object.

Run this 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 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);
    }
}

Possible output: 

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

[edit] See also

(C++11)
 a mixin type to capture and store current exceptions
(class) [edit]
(C++11)
 throws the exception from a std::nested_exception
(function template) [edit]
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/error/throw_with_nested&oldid=157700"