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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::out_of_range - std::out_of_range

Synopsis
	  Defined in header <stdexcept>
	  class	out_of_range;

	  Defines  a  type of object to	be thrown as exception.	It reports er-
       rors that are
	  consequence of attempt to access elements out	of defined range.

	  It may be thrown by the member functions of std::bitset and std::ba-
       sic_string, by
	  std::stoi and	std::stod families of functions, and  by  the  bounds-
       checked member
	  access functions (e.g. std::vector::at and std::map::at).

	  std-out of range-inheritance.svg

					  Inheritance diagram

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

       std::out_of_range::out_of_range

	  out_of_range(	const std::string& what_arg ); (1)
	  out_of_range(	const char* what_arg );	       (2)
	  out_of_range(	const out_of_range& 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::out_of_range
	  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::out_of_range is not permitted to throw	excep-
       tions, 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::out_of_range::operator=

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

	  Assigns  the	contents  with those of	other. If *this	and other both
       have dynamic type
	  std::out_of_range 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  standard	 error	condition std::errc::result_out_of_range typi-
       cally indicates the
	  condition where the result, rather than the input, is	out of	range,
       and is more
	  closely related to std::range_error and ERANGE.

	  Defect reports

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

	    DR	   Applied to	      Behavior as published		  Cor-
       rect behavior
	  LWG 254 C++98	     the constructor accepting const char*  added
			     was missing
			     the explanatory strings of		     they  are
       the same	as that
	  LWG 471 C++98	     std::out_of_range's		    of the
			     copies  were  implementation-defined     original
       std::out_of_range
								    object

See also
	  at	  accesses the specified character with	bounds checking
		  (public	member	     function	    of	      std::ba-
       sic_string<CharT,Traits,Allocator>)
	  at	  accesses the specified character with	bounds checking
		  (public	 member	      function	     of	      std::ba-
       sic_string_view<CharT,Traits>)
	  at	  access specified element with	bounds checking
		  (public member function of std::deque<T,Allocator>)
	  at	  access specified element with	bounds checking
		  (public member  function  of	std::map<Key,T,Compare,Alloca-
       tor>)
		  access specified element with	bounds checking
	  at	  (public member function of
		  std::unordered_map<Key,T,Hash,KeyEqual,Allocator>)
	  at	  access specified element with	bounds checking
		  (public member function of std::vector<T,Allocator>)
	  at	  access specified element with	bounds checking
		  (public member function of std::array<T,N>)
	  at	  access specified element with	bounds checking
	  (C++26) (public member function of std::span<T,Extent>)

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

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

home | help