Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::throw_with_nested(3)     C++ Standard Libary    std::throw_with_nested(3)

NAME
       std::throw_with_nested -	std::throw_with_nested

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

	  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::cur-
       rent_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

Parameters
	  t - the exception object to throw

Return value
	  (none)

Example
	  Demonstrates construction and	recursion through a  nested  exception
       object.

       // Run this code

	#include <iostream>
	#include <stdexcept>
	#include <exception>
	#include <string>
	#include <fstream>

	//  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

See also
	  nested_exception  a mixin type to capture and	store  current	excep-
       tions
	  (C++11)	    (class)
	  rethrow_if_nested throws the exception from a	std::nested_exception
	  (C++11)	    (function template)

http://cppreference.com		  2022.07.31	     std::throw_with_nested(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::throw_with_nested&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help