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

NAME
     std::current_exception - std::current_exception

Synopsis
	Defined in header <exception>
	std::exception_ptr current_exception() noexcept;  (since C++11)

	If called during exception handling (typically, in a catch clause), cap-
     tures the
	current  exception  object  and creates an std::exception_ptr that holds
     either a copy
	or a reference to that exception object (depending  on	the  implementa-
     tion). The
	referenced  object  remains valid at least as long as there is an excep-
     tion_ptr object
	that refers to it.

	If the implementation of this function requires a call to  new	and  the
     call fails,
	the   returned	 pointer  will	hold  a  reference  to	an  instance  of
     std::bad_alloc.

	If the implementation of this function requires copying the captured ex-
     ception
	object and its	copy  constructor  throws  an  exception,  the	returned
     pointer will hold
	a  reference  to  the  exception  thrown. If the copy constructor of the
     thrown exception
	object also throws, the returned pointer may hold a reference to an  in-
     stance of
	std::bad_exception to break the endless loop.

	If the function is called when no exception is being handled, an empty
	std::exception_ptr is returned.

	This  function can be called in a std::terminate_handler to retrieve the
     exception
	which has provoked the invocation of std::terminate.

Parameters
	(none)

Return value
	An instance of std::exception_ptr holding a reference to  the  exception
     object, or a
	copy  of the exception object, or to an instance of std::bad_alloc or to
     an instance
	of std::bad_exception.

Notes
	On the implementations that follow Itanium C++ ABI  (GCC,  Clang,  etc),
     exceptions are
	allocated  on  the  heap  when thrown (except for std::bad_alloc in some
     cases), and
	this function simply creates the smart pointer	referencing  the  previ-
     ously-allocated
	object, On MSVC, exceptions are allocated on stack when thrown, and this
     function
	performs the heap allocation and copies the exception object.

	On  Windows  in  managed  CLR  environments [1], the implementation will
     store a
	std::bad_exception when the current exception  is  a  managed  exception
     ([2]). Note
	that catch(...) catches also managed exceptions:

      #include <exception>

      int main()
      {
	  try
	  {
	      throw gcnew System::Exception("Managed exception");
	  }
	  catch (...)
	  {
	      std::exception_ptr ex = std::current_exception();
	      try
	      {
		  std::rethrow_exception(ex);
	      }
	      catch (std::bad_exception const &)
	      {
		  // This will be printed.
		  std::cout << "Bad exception" << std::endl;
	      }
	  }
      }

Example
     // Run this code

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

      void handle_eptr(std::exception_ptr eptr) // passing by value is ok
      {
	  try
	  {
	      if (eptr)
		  std::rethrow_exception(eptr);
	  }
	  catch(const std::exception& e)
	  {
	      std::cout << "Caught exception: '" << e.what() << "'\n";
	  }
      }

      int main()
      {
	  std::exception_ptr eptr;

	  try
	  {
	      std::string().at(1); // this generates a std::out_of_range
	  }
	  catch(...)
	  {
	      eptr = std::current_exception(); // capture
	  }

	  handle_eptr(eptr);

      }  //  destructor  for std::out_of_range called here, when the eptr is de-
     structed

Possible output:
      Caught exception: 'basic_string::at: __n	(which	is  1)	>=  this->size()
     (which is 0)'

See also
	exception_ptr	    shared pointer type for handling exception objects
	(C++11) 	    (typedef)
	rethrow_exception   throws the exception from an std::exception_ptr
	(C++11) 	    (function)
	make_exception_ptr   creates an std::exception_ptr from an exception ob-
     ject
	(C++11) 	    (function template)
	uncaught_exception
	uncaught_exceptions  checks  if  exception  handling  is  currently   in
     progress
	(removed in C++20)  (function)
	(C++17)

http://cppreference.com 	   2024.06.10	       std::current_exception(3)
home | help