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  std::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 std::nu-
       meric_limits
	  template. The	standard library makes available  specializations  for
       all arithmetic
	  types	 (only lists the specializations for cv-unqualified 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>;

	  The value of each member of a	specialization of  std::numeric_limits
       on a
	  cv-qualified	type  cv  T is equal to	the value of the corresponding
       member of the
	  specialization on the	unqualified type T. For	example,
	  std::numeric_limits<int>::digits  is	equal	to   std::numeric_lim-
       its<const int>::digits.

	  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 <iostream>
	#include <limits>

	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

	  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  201  C++98	specializations	 for all fundamental types ex-
       cluded non-arithmetic
			     need to be	provided		       types
			     it	was unclear whether the
			     std::numeric_limits
	  LWG 559 C++98	     specialization for	a  cv-qualified	 type	  they
       have the
			     behaves  as  the  same as			  same
       behavior
			     the corresponding specialization for the
			     cv-unqualified type

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

http://cppreference.com		  2024.06.10		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.1.quarterly>

home | help