limits

C语言库函数的原型,有用的拿去

		{	// return maximum value
		return (_ULLONG_MAX);
		}

 #if _HAS_CPP0X
	static _Ty __CRTDECL lowest() _THROW0()
		{	// return most negative value
		return ((min)());
		}
 #endif /* _HAS_CPP0X */

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (0);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (0);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (0);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (0);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (0);
		}

	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT * sizeof (_ULONGLONG));
	_STCONS(int, digits10, CHAR_BIT * sizeof (_ULONGLONG)
		* 301L / 1000);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + (CHAR_BIT * sizeof (_ULONGLONG))
		* 301L / 1000);
 #endif /* _HAS_CPP0X */
	};
 #endif /* _LONGLONG */

		// CLASS numeric_limits<float>
template<> class _CRTIMP2_PURE numeric_limits<float>
	: public _Num_float_base
	{	// limits for type float
public:
	typedef float _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (FLT_MIN);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (FLT_MAX);
		}

 #if _HAS_CPP0X
	static _Ty __CRTDECL lowest() _THROW0()
		{	// return most negative value
		return (-(max)());
		}
 #endif /* _HAS_CPP0X */

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (FLT_EPSILON);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0.5);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (_CSTD _FDenorm._Float);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (_CSTD _FInf._Float);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (_CSTD _FNan._Float);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (_CSTD _FSnan._Float);
		}

	_STCONS(int, digits, FLT_MANT_DIG);
	_STCONS(int, digits10, FLT_DIG);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + FLT_DIG);
 #endif /* _HAS_CPP0X */

	_STCONS(int, max_exponent, (int)FLT_MAX_EXP);
	_STCONS(int, max_exponent10, (int)FLT_MAX_10_EXP);
	_STCONS(int, min_exponent, (int)FLT_MIN_EXP);
	_STCONS(int, min_exponent10, (int)FLT_MIN_10_EXP);
	};

		// CLASS numeric_limits<double>
template<> class _CRTIMP2_PURE numeric_limits<double>
	: public _Num_float_base
	{	// limits for type double
public:
	typedef double _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (DBL_MIN);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (DBL_MAX);
		}

 #if _HAS_CPP0X
	static _Ty __CRTDECL lowest() _THROW0()
		{	// return most negative value
		return (-(max)());
		}
 #endif /* _HAS_CPP0X */

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (DBL_EPSILON);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0.5);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (_CSTD _Denorm._Double);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (_CSTD _Inf._Double);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (_CSTD _Nan._Double);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (_CSTD _Snan._Double);
		}

	_STCONS(int, digits, DBL_MANT_DIG);
	_STCONS(int, digits10, DBL_DIG);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + DBL_DIG);
 #endif /* _HAS_CPP0X */

	_STCONS(int, max_exponent, (int)DBL_MAX_EXP);
	_STCONS(int, max_exponent10, (int)DBL_MAX_10_EXP);
	_STCONS(int, min_exponent, (int)DBL_MIN_EXP);
	_STCONS(int, min_exponent10, (int)DBL_MIN_10_EXP);
	};

		// CLASS numeric_limits<long double>
template<> class _CRTIMP2_PURE numeric_limits<long double>
	: public _Num_float_base
	{	// limits for type long double
public:
	typedef long double _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (LDBL_MIN);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (LDBL_MAX);
		}

 #if _HAS_CPP0X
	static _Ty __CRTDECL lowest() _THROW0()
		{	// return most negative value
		return (-(max)());
		}
 #endif /* _HAS_CPP0X */

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (LDBL_EPSILON);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0.5);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (_CSTD _LDenorm._Long_double);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (_CSTD _LInf._Long_double);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (_CSTD _LNan._Long_double);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (_CSTD _LSnan._Long_double);
		}

	_STCONS(int, digits, LDBL_MANT_DIG);
	_STCONS(int, digits10, LDBL_DIG);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + LDBL_DIG);
 #endif /* _HAS_CPP0X */

	_STCONS(int, max_exponent, (int)LDBL_MAX_EXP);
	_STCONS(int, max_exponent10, (int)LDBL_MAX_10_EXP);
	_STCONS(int, min_exponent, (int)LDBL_MIN_EXP);
	_STCONS(int, min_exponent10, (int)LDBL_MIN_10_EXP);
	};

  #if !defined(_MSC_EXTENSIONS) && !defined(_DLL) && !defined(_STATIC_CPPLIB)
   #undef _STCONS
   #define _STCONS(ty, name, val)	\
		__declspec(selectany) const ty _STCLASS::name

  #undef _STCLASS
  #define _STCLASS	_Num_base
	_STCONS(float_denorm_style, has_denorm, denorm_absent);
	_STCONS(bool, has_denorm_loss, false);
	_STCONS(bool, has_infinity, false);
	_STCONS(bool, has_quiet_NaN, false);
	_STCONS(bool, has_signaling_NaN, false);
	_STCONS(bool, is_bounded, false);
	_STCONS(bool, is_exact, false);
	_STCONS(bool, is_iec559, false);
	_STCONS(bool, is_integer, false);
	_STCONS(bool, is_modulo, false);
	_STCONS(bool, is_signed, false);
	_STCONS(bool, is_specialized, false);
	_STCONS(bool, tinyness_before, false);
	_STCONS(bool, traps, false);
	_STCONS(float_round_style, round_style, round_toward_zero);
	_STCONS(int, digits, 0);
	_STCONS(int, digits10, 0);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 0);
 #endif /* _HAS_CPP0X */

	_STCONS(int, max_exponent, 0);
	_STCONS(int, max_exponent10, 0);
	_STCONS(int, min_exponent, 0);
	_STCONS(int, min_exponent10, 0);
	_STCONS(int, radix, 0);

  #undef _STCLASS
  #define _STCLASS	_Num_int_base
	_STCONS(bool, is_bounded, true);
	_STCONS(bool, is_exact, true);
	_STCONS(bool, is_integer, true);
	_STCONS(bool, is_modulo, true);
	_STCONS(bool, is_specialized, true);
	_STCONS(int, radix, 2);

  #undef _STCLASS
  #define _STCLASS	_Num_float_base
	_STCONS(float_denorm_style, has_denorm, denorm_present);
	_STCONS(bool, has_denorm_loss, true);
	_STCONS(bool, has_infinity, true);
	_STCONS(bool, has_quiet_NaN, true);
	_STCONS(bool, has_signaling_NaN, true);
	_STCONS(bool, is_bounded, true);
	_STCONS(bool, is_exact, false);
	_STCONS(bool, is_iec559, true);
	_STCONS(bool, is_integer, false);
	_STCONS(bool, is_modulo, false);
	_STCONS(bool, is_signed, true);
	_STCONS(bool, is_specialized, true);
	_STCONS(bool, tinyness_before, true);
	_STCONS(bool, traps, true);
	_STCONS(float_round_style, round_style, round_to_nearest);
	_STCONS(int, radix, FLT_RADIX);

  #undef _STCLASS
  #define _STCLASS	numeric_limits<char>
	_STCONS(bool, is_signed, CHAR_MIN != 0);
	_STCONS(int, digits, CHAR_BIT - (CHAR_MIN != 0 ? 1 : 0));
	_STCONS(int, digits10, (CHAR_BIT - (CHAR_MIN != 0 ? 1 : 0) - 1)
		* 301L / 1000);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + (CHAR_BIT - (CHAR_MIN != 0 ? 1 : 0))
		* 301L / 1000);
 #endif /* _HAS_CPP0X */

  #undef _STCLASS
  #define _STCLASS	numeric_limits<wchar_t>
	_STCONS(bool, is_signed, WCHAR_MIN != 0);
	_STCONS(int, digits, CHAR_BIT * sizeof (wchar_t)
		- (WCHAR_MIN != 0 ? 1 : 0));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (wchar_t)
		- (WCHAR_MIN != 0 ? 1 : 0) - 1) * 301L / 1000);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + (CHAR_BIT * sizeof (wchar_t)
		- (WCHAR_MIN != 0 ? 1 : 0)) * 301L / 1000);
 #endif /* _HAS_CPP0X */

  #undef _STCLASS
  #define _STCLASS	numeric_limits<_Bool>
	_STCONS(bool, is_modulo, false);
	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, 1);
	_STCONS(int, digits10, 0);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 0);
 #endif /* _HAS_CPP0X */

  #undef _STCLASS
  #define _STCLASS	numeric_limits<signed char>
	_STCONS(bool, is_signed, true);
	_STCONS(int, digits, CHAR_BIT - 1);
	_STCONS(int, digits10, (CHAR_BIT - 1 - 1) * 301L / 1000);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + (CHAR_BIT - 1) * 301L / 1000);
 #endif /* _HAS_CPP0X */

  #undef _STCLASS
  #define _STCLASS	numeric_limits<unsigned char>
	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT);
	_STCONS(int, digits10, (CHAR_BIT - 1) * 301L / 1000);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + (CHAR_BIT) * 301L / 1000);
 #endif /* _HAS_CPP0X */

  #undef _STCLASS
  #define _STCLASS	numeric_limits<short>
	_STCONS(bool, is_signed, true);
	_STCONS(int, digits, CHAR_BIT * sizeof (short) - 1);
	_STCONS(int, digits10, (CHAR_BIT * sizeof (short) - 1 - 1)
		* 301L / 1000);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + (CHAR_BIT * sizeof (short) - 1)
		* 301L / 1000);
 #endif /* _HAS_CPP0X */

  #undef _STCLASS
  #define _STCLASS	numeric_limits<unsigned short>
	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT * sizeof (unsigned short));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned short) - 1)
		* 301L / 1000);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + (CHAR_BIT * sizeof (unsigned short))
		* 301L / 1000);
 #endif /* _HAS_CPP0X */

 #if _HAS_CHAR16_T_LANGUAGE_SUPPORT
  #undef _STCLASS
  #define _STCLASS	numeric_limits<char16_t>
	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT * sizeof (char16_t));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (char16_t) - 1)
		* 301L / 1000);
	_STCONS(int, max_digits10, 2 + (CHAR_BIT * sizeof (char16_t))
		* 301L / 1000);
 #endif /* _HAS_CHAR16_T_LANGUAGE_SUPPORT */

  #undef _STCLASS
  #define _STCLASS	numeric_limits<int>
	_STCONS(bool, is_signed, true);
	_STCONS(int, digits, CHAR_BIT * sizeof (int) - 1);
	_STCONS(int, digits10, (CHAR_BIT * sizeof (int) - 1 - 1)
		* 301L / 1000);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + (CHAR_BIT * sizeof (int) - 1)
		* 301L / 1000);
 #endif /* _HAS_CPP0X */

  #undef _STCLASS
  #define _STCLASS	numeric_limits<unsigned int>
	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT * sizeof (unsigned int));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned int) - 1)
		* 301L / 1000);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + (CHAR_BIT * sizeof (unsigned int))
		* 301L / 1000);
 #endif /* _HAS_CPP0X */

  #undef _STCLASS
  #define _STCLASS	numeric_limits<long>
	_STCONS(bool, is_signed, true);
	_STCONS(int, digits, CHAR_BIT * sizeof (long) - 1);
	_STCONS(int, digits10, (CHAR_BIT * sizeof (long) - 1 - 1)
		* 301L / 1000);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + (CHAR_BIT * sizeof (long) - 1)
		* 301L / 1000);
 #endif /* _HAS_CPP0X */

  #undef _STCLASS
  #define _STCLASS	numeric_limits<unsigned long>
	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT * sizeof (unsigned long));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned long) - 1)
		* 301L / 1000);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + (CHAR_BIT * sizeof (unsigned long))
		* 301L / 1000);
 #endif /* _HAS_CPP0X */

 #if _HAS_CHAR16_T_LANGUAGE_SUPPORT
  #undef _STCLASS
  #define _STCLASS	numeric_limits<char32_t>
	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT * sizeof (char32_t));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (char32_t) - 1)
		* 301L / 1000);
	_STCONS(int, max_digits10, 2 + (CHAR_BIT * sizeof (char32_t))
		* 301L / 1000);
 #endif /* _HAS_CHAR16_T_LANGUAGE_SUPPORT */

 #ifdef _LONGLONG
  #undef _STCLASS
  #define _STCLASS	numeric_limits<_LONGLONG>
	_STCONS(bool, is_signed, true);
	_STCONS(int, digits, CHAR_BIT * sizeof (_LONGLONG) - 1);
	_STCONS(int, digits10, (CHAR_BIT * sizeof (_LONGLONG) - 1 - 1)
		* 301L / 1000);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + (CHAR_BIT * sizeof (_LONGLONG) - 1)
		* 301L / 1000);
 #endif /* _HAS_CPP0X */

  #undef _STCLASS
  #define _STCLASS	numeric_limits<_ULONGLONG>
	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT * sizeof (_ULONGLONG));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (_ULONGLONG) - 1)
		* 301L / 1000);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + (CHAR_BIT * sizeof (_ULONGLONG))
		* 301L / 1000);
 #endif /* _HAS_CPP0X */

 #endif /* _LONGLONG */

  #undef _STCLASS
  #define _STCLASS	numeric_limits<float>
	_STCONS(int, digits, FLT_MANT_DIG);
	_STCONS(int, digits10, FLT_DIG);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + FLT_DIG);
 #endif /* _HAS_CPP0X */

	_STCONS(int, max_exponent, (int)FLT_MAX_EXP);
	_STCONS(int, max_exponent10, (int)FLT_MAX_10_EXP);
	_STCONS(int, min_exponent, (int)FLT_MIN_EXP);
	_STCONS(int, min_exponent10, (int)FLT_MIN_10_EXP);

  #undef _STCLASS
  #define _STCLASS	numeric_limits<double>
	_STCONS(int, digits, DBL_MANT_DIG);
	_STCONS(int, digits10, DBL_DIG);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + DBL_DIG);
 #endif /* _HAS_CPP0X */

	_STCONS(int, max_exponent, (int)DBL_MAX_EXP);
	_STCONS(int, max_exponent10, (int)DBL_MAX_10_EXP);
	_STCONS(int, min_exponent, (int)DBL_MIN_EXP);
	_STCONS(int, min_exponent10, (int)DBL_MIN_10_EXP);

  #undef _STCLASS
  #define _STCLASS	numeric_limits<long double>
	_STCONS(int, digits, LDBL_MANT_DIG);
	_STCONS(int, digits10, LDBL_DIG);

 #if _HAS_CPP0X
	_STCONS(int, max_digits10, 2 + LDBL_DIG);
 #endif /* _HAS_CPP0X */

	_STCONS(int, max_exponent, (int)LDBL_MAX_EXP);
	_STCONS(int, max_exponent10, (int)LDBL_MAX_10_EXP);
	_STCONS(int, min_exponent, (int)LDBL_MIN_EXP);
	_STCONS(int, min_exponent10, (int)LDBL_MIN_10_EXP);
  #endif /* !defined(_MSC_EXTENSIONS) etc. */
_STD_END
 #pragma warning(pop)
 #pragma pack(pop)

#endif /* RC_INVOKED */
#endif /* _LIMITS_ */

/*
 * Copyright (c) 1992-2009 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
V5.20:0009 */