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

NAME
     std::underflow_error - std::underflow_error

Synopsis
	Defined in header <stdexcept>
	class underflow_error;

	Defines  a  type  of object to be thrown as exception. It may be used to
     report
	arithmetic underflow errors (that is, situations where the result  of  a
     computation
	is a subnormal floating-point value).

	The  standard library components do not throw this exception (mathemati-
     cal functions
	report underflow errors as specified in  math_errhandling).  Third-party
     libraries,
	however,  use  this. For example, boost.math throws std::underflow_error
     if
	boost::math::policies::throw_on_error is enabled (the default setting).

	std-underflow error-inheritance.svg

					Inheritance diagram

Member functions
	constructor   constructs a new underflow_error	object	with  the  given
     message
		      (public member function)
	operator=     replaces the underflow_error object
		      (public member function)

     std::underflow_error::underflow_error

	underflow_error( const std::string& what_arg );  (1)
	underflow_error( const char* what_arg );	 (2)
	underflow_error(  const  underflow_error&  other  ); (3) (noexcept since
     C++11)

	1) Constructs the exception object with what_arg as explanatory  string.
     After
	construction, std::strcmp(what(), what_arg.c_str()) == 0.
	2)  Constructs the exception object with what_arg as explanatory string.
     After
	construction, std::strcmp(what(), what_arg) == 0.
	3) Copy constructor. If *this and other both have dynamic type	std::un-
     derflow_error
	then  std::strcmp(what(), other.what()) == 0. No exception can be thrown
     from the
	copy constructor.

Parameters
	what_arg - explanatory string
	other	 - another exception object to copy

Exceptions
	1,2) May throw std::bad_alloc.

Notes
	Because copying std::underflow_error is not permitted  to  throw  excep-
     tions, this
	message  is typically stored internally as a separately-allocated refer-
     ence-counted
	string. This is also why there is no constructor  taking  std::string&&:
     it would have
	to copy the content anyway.

	Before	the  resolution  of  LWG issue 254, the non-copy constructor can
     only accept
	std::string. It makes dynamic allocation mandatory in order to construct
     a
	std::string object.

	After the resolution of LWG issue  471,  a  derived  standard  exception
     class must have
	a  publicly accessible copy constructor. It can be implicitly defined as
     long as the
	explanatory strings obtained by what() are the same for the original ob-
     ject and the
	copied object.

     std::underflow_error::operator=

	underflow_error& operator=( const underflow_error& other  );   (noexcept
     since C++11)

	Assigns  the  contents with those of other. If *this and other both have
     dynamic type
	std::underflow_error then std::strcmp(what(), other.what()) ==	0  after
     assignment.
	No exception can be thrown from the copy assignment operator.

Parameters
	other - another exception object to assign with

Return value
	*this

Notes
	After  the  resolution	of  LWG  issue 471, a derived standard exception
     class must have
	a publicly accessible copy assignment operator. It can be implicitly de-
     fined as long
	as the explanatory strings obtained by what() are the same for the orig-
     inal object
	and the copied object.

     Inherited from std::runtime_error

     Inherited from std::exception

Member functions
	destructor   destroys the exception object
	[virtual]    (virtual public member function of std::exception)
	what	     returns an explanatory string
	[virtual]    (virtual public member function of std::exception)

	Defect reports

	The following behavior-changing defect	reports  were  applied	retroac-
     tively to
	previously published C++ standards.

	  DR	Applied to	  Behavior as published 	     Correct be-
     havior
	LWG 254 C++98	   the constructor accepting const     added
			   char* was missing
			   the explanatory strings of	       they are the same
     as that of
	LWG 471 C++98	   std::underflow_error's	       the
			   copies were implementation-defined  original std::un-
     derflow_error
							       object

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