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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::numeric_limits - std::numeric_limits

Synopsis
	  Defined in header <limits>
	  template< class T > class numeric_limits;

	  The  numeric_limits  class  template	provides a standardized	way to
       query various
	  properties of	arithmetic types (e.g. the largest possible value  for
       type int	is
	  std::numeric_limits<int>::max()).

	  This information is provided via specializations of the numeric_lim-
       its template. The
	  standard  library makes available specializations for	all arithmetic
       types:

	  Defined in header <limits>
	  template<> class numeric_limits<bool>;
	  template<> class numeric_limits<char>;
	  template<> class numeric_limits<signed char>;
	  template<> class numeric_limits<unsigned char>;
	  template<> class numeric_limits<wchar_t>;
	  template<> class numeric_limits<char8_t>;		(since C++20)
	  template<> class numeric_limits<char16_t>;		(since C++11)
	  template<> class numeric_limits<char32_t>;		(since C++11)
	  template<> class numeric_limits<short>;
	  template<> class numeric_limits<unsigned short>;
	  template<> class numeric_limits<int>;
	  template<> class numeric_limits<unsigned int>;
	  template<> class numeric_limits<long>;
	  template<> class numeric_limits<unsigned long>;
	  template<> class numeric_limits<long long>;		(since C++11)
	  template<> class numeric_limits<unsigned long	long>;	(since C++11)
	  template<> class numeric_limits<float>;
	  template<> class numeric_limits<double>;
	  template<> class numeric_limits<long double>;

	  Additionally,	a specialization exists	for every cv-qualified version
       of each
	  cv-unqualified type for which	the specialization  exists,  identical
       to the
	  unqualified specialization, e.g. std::numeric_limits<const int>,
	  std::numeric_limits<volatile	 int>,	and  std::numeric_limits<const
       volatile	int> are
	  provided and are equivalent to std::numeric_limits<int>.

	  Aliases of arithmetic	types (such as std::size_t or std::streamsize)
       may also	be
	  examined with	the std::numeric_limits	type traits.

	  Non-arithmetic  standard   types,   such   as	  std::complex<T>   or
       std::nullptr_t, do not
	  have specializations.

	  If  the  implementation defines any integer-class types, specializa-
       tions (since C++20)
	  of std::numeric_limits must also be provided for them.

	  Implementations may provide specializations  of  std::numeric_limits
       for
	  implementation-specific  types:  e.g.	GCC provides std::numeric_lim-
       its<__int128>.
	  Non-standard libraries may add specializations for  library-provided
       types, e.g.
	  OpenEXR  provides  std::numeric_limits<half>	for a 16-bit floating-
       point type.

Template parameters
	  T - a	type to	retrieve numeric properties for

Member constants
	  is_specialized    identifies types for which std::numeric_limits  is
       specialized
	  [static]	    (public static member constant)
	  is_signed	    identifies signed types
	  [static]	    (public static member constant)
	  is_integer	    identifies integer types
	  [static]	    (public static member constant)
	  is_exact	    identifies exact types
	  [static]	    (public static member constant)
	  has_infinity	    identifies floating-point types that can represent
       the special
	  [static]	    value "positive infinity"
			    (public static member constant)
	  has_quiet_NaN	    identifies floating-point types that can represent
       the special
	  [static]	    value "quiet not-a-number" (NaN)
			    (public static member constant)
	  has_signaling_NaN identifies floating-point types that can represent
       the special
	  [static]	    value "signaling not-a-number" (NaN)
			    (public static member constant)
	  has_denorm	     identifies	 the denormalization style used	by the
       floating-point
	  [static]	    type
			    (public static member constant)
	  has_denorm_loss   identifies the floating-point  types  that	detect
       loss of precision
	  [static]	    as denormalization loss rather than	inexact	result
			    (public static member constant)
	  round_style	    identifies the rounding style used by the type
	  [static]	    (public static member constant)
	  is_iec559	     identifies	 the  IEC  559/IEEE 754	floating-point
       types
	  [static]	    (public static member constant)
	  is_bounded	    identifies types that represent a  finite  set  of
       values
	  [static]	    (public static member constant)
	  is_modulo	    identifies types that handle overflows with	modulo
       arithmetic
	  [static]	    (public static member constant)
	  digits	     number  of	 radix	digits that can	be represented
       without change
	  [static]	    (public static member constant)
	  digits10	    number of decimal digits that can  be  represented
       without change
	  [static]	    (public static member constant)
	  max_digits10	     number of decimal digits necessary	to differenti-
       ate all values of
	  [static] (C++11)  this type
			    (public static member constant)
	  radix		    the	radix or integer base used by the  representa-
       tion of the given
	  [static]	    type
			    (public static member constant)
	  min_exponent	     one  more than the	smallest negative power	of the
       radix that is a
	  [static]	    valid normalized floating-point value
			    (public static member constant)
	  min_exponent10    the	smallest negative power	of ten that is a valid
       normalized
	  [static]	    floating-point value
			    (public static member constant)
	  max_exponent	    one	more than the largest  integer	power  of  the
       radix that is a
	  [static]	    valid finite floating-point	value
			    (public static member constant)
	  max_exponent10     the  largest  integer power of 10 that is a valid
       finite
	  [static]	    floating-point value
			    (public static member constant)
	  traps		    identifies types which can cause arithmetic	opera-
       tions to	trap
	  [static]	    (public static member constant)
	  tinyness_before   identifies floating-point types that detect	 tiny-
       ness before
	  [static]	    rounding
			    (public static member constant)

Member functions
	  min		   returns the smallest	finite value of	the given type
	  [static]	   (public static member function)
	  lowest	   returns the lowest finite value of the given	type
	  [static] (C++11) (public static member function)
	  max		   returns the largest finite value of the given type
	  [static]	   (public static member function)
	  epsilon	    returns  the  difference  between 1.0 and the next
       representable value
	  [static]	   of the given	floating-point type
			   (public static member function)
	  round_error	   returns the maximum rounding	 error	of  the	 given
       floating-point type
	  [static]	   (public static member function)
	  infinity	    returns  the  positive infinity value of the given
       floating-point
	  [static]	   type
			   (public static member function)
	  quiet_NaN	   returns a quiet NaN value of	 the  given  floating-
       point type
	  [static]	   (public static member function)
	  signaling_NaN	    returns  a signaling NaN value of the given	float-
       ing-point type
	  [static]	   (public static member function)
	  denorm_min	   returns the smallest	positive  subnormal  value  of
       the given
	  [static]	   floating-point type
			   (public static member function)

Helper classes
	  float_round_style  indicates floating-point rounding modes
			     (enum)
	  float_denorm_style indicates floating-point denormalization modes
			     (enum)

Relationship with C library macro constants
	      Specialization			      Members
	  std::numeric_limits<T>   min()   lowest()	  max()	      radix
		where T	is		    (C++11)
	  bool			 false	   false     true	      2
	  char			 CHAR_MIN  CHAR_MIN  CHAR_MAX	      2
	  signed char		 SCHAR_MIN SCHAR_MIN SCHAR_MAX	      2
	  unsigned char		 0   0	 UCHAR_MAX	  2
	  wchar_t		 WCHAR_MIN WCHAR_MIN WCHAR_MAX	      2
	  char8_t		 0   0	 UCHAR_MAX	  2
	  char16_t		 0   0	 UINT_LEAST16_MAX 2
	  char32_t		 0   0	 UINT_LEAST32_MAX 2
	  short			 SHRT_MIN  SHRT_MIN  SHRT_MAX	      2
	  signed short
	  unsigned short	 0   0	 USHRT_MAX	  2
	  int			 INT_MIN   INT_MIN   INT_MAX	      2
	  signed int
	  unsigned int		 0   0	 UINT_MAX	  2
	  long			 LONG_MIN  LONG_MIN  LONG_MAX	      2
	  signed long
	  unsigned long		 0   0	 ULONG_MAX	  2
	  long long		 LLONG_MIN LLONG_MIN LLONG_MAX	      2
	  signed long long
	  unsigned long	long	 0   0	 ULLONG_MAX	  2

	   Specialization					       Members
       std::numeric_limits<T> denorm_min()   min()   lowest()	 max()	   ep-
       silon()	    digits     digits10
	     where    T	   is				       (C++11)	 float
       FLT_TRUE_MIN  FLT_MIN   -FLT_MAX	  FLT_MAX   FLT_EPSILON	  FLT_MANT_DIG
       FLT_DIG double		      DBL_TRUE_MIN  DBL_MIN  -DBL_MAX  DBL_MAX
       DBL_EPSILON  DBL_MANT_DIG  DBL_DIG long double		 LDBL_TRUE_MIN
       LDBL_MIN	-LDBL_MAX LDBL_MAX LDBL_EPSILON	LDBL_MANT_DIG LDBL_DIG

	   Specialization				   Members  (continue)
       std::numeric_limits<T>
	     where  T  is	 min_exponent	min_exponent10	  max_exponent
       max_exponent10	      radix	float			   FLT_MIN_EXP
       FLT_MIN_10_EXP	 FLT_MAX_EXP	FLT_MAX_10_EXP	   FLT_RADIX	double
       DBL_MIN_EXP   DBL_MIN_10_EXP   DBL_MAX_EXP   DBL_MAX_10_EXP   FLT_RADIX
       long  double		 LDBL_MIN_EXP	LDBL_MIN_10_EXP	  LDBL_MAX_EXP
       LDBL_MAX_10_EXP FLT_RADIX

Example
       // Run this code

	#include <limits>
	#include <iostream>

	int main()
	{
	    std::cout
		<< "type\t lowest()\t min()\t\t	max()\n"
		<< "bool\t "
		<< std::numeric_limits<bool>::lowest() << "\t\t	"
		<< std::numeric_limits<bool>::min() << "\t\t "
		<< std::numeric_limits<bool>::max() << '\n'
		<< "uchar\t "
		<< +std::numeric_limits<unsigned char>::lowest() << "\t\t "
		<< +std::numeric_limits<unsigned char>::min() << "\t\t "
		<< +std::numeric_limits<unsigned char>::max() << '\n'
		<< "int\t "
		<< std::numeric_limits<int>::lowest() << "\t "
		<< std::numeric_limits<int>::min() << "\t "
		<< std::numeric_limits<int>::max() << '\n'
		<< "float\t "
		<< std::numeric_limits<float>::lowest()	<< "\t "
		<< std::numeric_limits<float>::min() <<	"\t "
		<< std::numeric_limits<float>::max() <<	'\n'
		<< "double\t "
		<< std::numeric_limits<double>::lowest() << "\t	"
		<< std::numeric_limits<double>::min() << "\t "
		<< std::numeric_limits<double>::max() << '\n';
	}

Possible output:
	type	 lowest()     min()		   max()
	bool	 0	      0		   1
	uchar	 0	      0		   255
	int	 -2147483648  -2147483648  2147483647
	float	 -3.40282e+38	      1.17549e-38  3.40282e+38
	double	 -1.79769e+308	      2.22507e-308	   1.79769e+308

See also
	    * Fixed width integer types
	    * Arithmetic types
	    * C++ type system overview
	    * Type support (basic types, RTTI, type traits)

http://cppreference.com		  2022.07.31		std::numeric_limits(3)

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

home | help