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

NAME
     std::invalid_argument - std::invalid_argument

Synopsis
	Defined in header <stdexcept>
	class invalid_argument;

	Defines  a  type  of object to be thrown as exception. It reports errors
     that arise
	because an argument value has not been accepted.

	This exception is thrown by std::bitset::bitset, and the  std::stoi  and
     std::stof
	families of functions.

	std-invalid argument-inheritance.svg

					Inheritance diagram

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

     std::invalid_argument::invalid_argument

	invalid_argument( const std::string& what_arg );   (1)
	invalid_argument( const char* what_arg );	   (2)
	invalid_argument( const invalid_argument& 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::in-
     valid_argument
	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::invalid_argument 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::invalid_argument::operator=

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

	Assigns the contents with those of other. If *this and other  both  have
     dynamic type
	std::invalid_argument  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::logic_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)

Notes
	The purpose of this exception type is similar to the error condition
	std::errc::invalid_argument  (thrown  in  std::system_error  from member
     functions of
	std::thread) and the related errno constant EINVAL.

Example
     // Run this code

      #include <bitset>
      #include <iostream>
      #include <stdexcept>
      #include <string>

      int main()
      {
	  try
	  {
	      std::bitset<4>{"012"}; // Throws: only '0' or '1' expected
	  }
	  catch (std::invalid_argument const& ex)
	  {
	      std::cout << "#1: " << ex.what() << '\n';
	  }

	  try
	  {
	      [[maybe_unused]] int f = std::stoi("ABBA"); // Throws: no  conver-
     sion
	  }
	  catch (std::invalid_argument const& ex)
	  {
	      std::cout << "#2: " << ex.what() << '\n';
	  }

	  try
	  {
	      [[maybe_unused]] float f = std::stof("(3.14)"); // Throws: no con-
     version
	  }
	  catch (std::invalid_argument const& ex)
	  {
	      std::cout << "#3: " << ex.what() << '\n';
	  }
      }

Possible output:
      #1: bitset string ctor has invalid argument
      #2: stoi: no conversion
      #3: stof: no conversion

	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::invalid_argument's	      the
			   copies  were implementation-defined original std::in-
     valid_argument
							      object

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