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

FreeBSD Manual Pages

  
 
  

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 er-
       rors 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::invalid_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 ex-
       ceptions, this
	  message is typically stored  internally  as  a  separately-allocated
       reference-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  con-
       struct 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
       object and the
	  copied object.

       std::invalid_argument::operator=

	  invalid_argument& operator=( const invalid_argument& other	(noex-
       cept 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
       defined as long
	  as  the  explanatory strings obtained	by what() are the same for the
       original	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 con-
       version
	    }
	    catch (std::invalid_argument const&	ex)
	    {
		std::cout << "#2: " << ex.what() << '\n';
	    }

	    try
	    {
		[[maybe_unused]] float f = std::stof("(3.14)");	// Throws:  no
       conversion
	    }
	    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
       behavior
	  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::invalid_argument
								object

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

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

home | help