ไลบรารี C ++ - <limits>

บทนำ

เป็นประเภทขีด จำกัด ตัวเลขและให้ข้อมูลเกี่ยวกับคุณสมบัติของประเภทเลขคณิต (ทั้งอินทิกรัลหรือทศนิยม) ในแพลตฟอร์มเฉพาะที่ไลบรารีคอมไพล์

คำประกาศ

ต่อไปนี้เป็นการประกาศสำหรับ std :: numeric_limits

template <class T> numeric_limits;

C ++ 11

template <class T> numeric_limits;

พารามิเตอร์

T - เป็นประเภทของคลาส

ตัวอย่าง

ในตัวอย่างด้านล่างสำหรับ std :: numeric_limits

#include <limits>
#include <iostream>

int main() {
   std::cout << "type\tlowest type\thighest type\n";
   std::cout << "int\t"
      << std::numeric_limits<int>::lowest() << '\t'
      << std::numeric_limits<int>::max() << '\n';
   std::cout << "float\t"
      << std::numeric_limits<float>::lowest() << '\t'
      << std::numeric_limits<float>::max() << '\n';
   std::cout << "double\t"
      << std::numeric_limits<double>::lowest() << '\t'
      << std::numeric_limits<double>::max() << '\n';
}

ผลลัพธ์ตัวอย่างควรเป็นดังนี้ -

type	lowest type	highest type
int	-2147483648	2147483647
float	-3.40282e+38	3.40282e+38
double	-1.79769e+308	1.79769e+308

การสร้างอินสแตนซ์เทมเพลต

ประเภทเลขคณิตพื้นฐานของ C ++ 98 ควรเป็นดังนี้ -

ประเภทเลขคณิตพื้นฐาน
ประเภทอินทิกรัล	`bool`
	`char`
	`wchar_t`
	`signed char`
	`short int`
	`int`
	`long int`
	`unsigned char`
	`unsigned short int`
	`unsigned int`
	`unsigned long int`
ประเภทจุดลอยตัว	`float`
	`double`
	`long double`

ประเภทเลขคณิตพื้นฐานของ C ++ 11 ควรเป็นดังนี้ -

ประเภทเลขคณิตพื้นฐาน
ประเภทอินทิกรัล	`bool`
	`char`
	`char16_t`
	`char32_t`
	`wchar_t`
	`signed char`
	`short int`
	`int`
	`long int`
	`long long int`
	`unsigned char`
	`unsigned short int`
	`unsigned int`
	`unsigned long int`
	`unsigned long long int`
ประเภทจุดลอยตัว	`float`
	`double`
	`long double`

สมาชิก

สมาชิก	ชนิด	ทรัพย์สิน
`is_specialized`	`bool`	มันมี`true`ไว้สำหรับทุกคน (กล่าวคือสิ่งที่`numeric_limits`เชี่ยวชาญ) และ`false`สำหรับประเภทอื่น ๆ ทั้งหมด
`นาที()`	`ที`	เป็นค่า จำกัด ขั้นต่ำ สำหรับประเภทลอยที่มีการทำให้เป็นมาตรฐาน (จำนวนตัวแปรของเลขชี้กำลัง): ค่ามาตรฐานต่ำสุดที่เป็นบวก เทียบเท่ากับ `CHAR_MIN`, `SCHAR_MIN`, `SHRT_MIN`, `INT_MIN`, `LONG_MIN`, `LLONG_MIN`, `FLT_MIN`, `BL_MIN`, `LDBL_MIN`หรือ`0`ขึ้นอยู่กับประเภท
`สูงสุด ()`	`ที`	เป็นค่า จำกัด สูงสุด เทียบเท่ากับ `CHAR_MAX`, `SCHAR_MAX`, `UCHAR_MAX`, `SHRT_MAX`, `USHRT_MAX`, `INT_MAX`, `UINT_MAX`, `LONG_MAX`, `ULONG_MAX`, `LLONG_MAX`, `ULLONG_MAX`, `UINT_LEAST16_MAX`, `UINT_LEAST32_MAX`, `FLT_MAX`, `DBL_MAX` หรือ `LDBL_MAX`ขึ้นอยู่กับประเภท
`ต่ำสุด ()`	`ที`	เป็นค่า จำกัด ขั้นต่ำ (ตั้งแต่ C ++ 11) สำหรับประเภทอินทิกรัล: เช่นเดียวกับ `นาที()`. สำหรับประเภททศนิยม: ขึ้นอยู่กับการใช้งาน; โดยทั่วไปค่าลบของ`สูงสุด ()`.
`ตัวเลข`	`int`	มันเป็นชนิดจำนวนเต็ม: จำนวนบิตไม่ใช่สัญญาณ ( `Radix`ตัวเลขฐาน) ในการเป็นตัวแทน สำหรับประเภทลอย: จำนวนหลัก (ใน`ฐานรัศมี` ) ในแมนทิสซา (เทียบเท่ากับ`FLT_MANT_DIG`, `DBL_MANT_DIG` หรือ `LDBL_MANT_DIG`).
`หลัก 10`	`int`	เป็นตัวเลขจำนวนหนึ่ง (ในฐานทศนิยม) ซึ่งสามารถแสดงได้โดยไม่มีการเปลี่ยนแปลง เทียบเท่ากับ `FLT_DIG`, `DBL_DIG` หรือ `LDBL_DIG` สำหรับประเภทลอย
`max_digits 10`	`int`	เป็นตัวเลขจำนวนหนึ่ง (ในฐานทศนิยม) ซึ่งจำเป็นเพื่อให้แน่ใจว่าค่าที่แตกต่างกันจะมีความแตกต่างเสมอ
`is_signed`	`bool`	`true` หากมีการลงนามประเภท
`is_integer`	`bool`	`true` ถ้าประเภทเป็นจำนวนเต็ม
`is_exact`	`bool`	`true` ถ้าประเภทใช้การแสดงที่แน่นอน
`รัศมี`	`int`	สำหรับประเภทจำนวนเต็ม: ฐานของการเป็นตัวแทน สำหรับประเภทลอย: ฐานของเลขชี้กำลังของการเป็นตัวแทน (เทียบเท่ากับ `FLT_RADIX`).
`เอปไซลอน ()`	`ที`	มันคือเครื่องจักร epsilon (ความแตกต่างระหว่าง 1 และค่าน้อยที่สุดที่มากกว่า 1 ที่เป็นตัวแทนได้) เทียบเท่ากับ `FLT_EPSILON`, `DBL_EPSILON` หรือ `LDBL_EPSILON` สำหรับประเภทลอย
`round_error ()`	`ที`	เป็นการวัดข้อผิดพลาดในการปัดเศษสูงสุด
`min_exponent`	`int`	เป็นค่าจำนวนเต็มลบขั้นต่ำที่`รัศมี`ยกขึ้นเพื่อ`(min_exponent-1)`สร้างตัวเลขทศนิยมที่เป็นมาตรฐาน เทียบเท่ากับ `FLT_MIN_EXP`, `DBL_MIN_EXP` หรือ `LDBL_MIN_EXP` สำหรับประเภทลอย
`min_exponent10`	`int`	เป็นค่าจำนวนเต็มลบขั้นต่ำเช่น 10 ยกกำลังนั้นจะสร้างตัวเลขทศนิยมที่เป็นมาตรฐาน เทียบเท่ากับ `FLT_MIN_10_EXP`, `DBL_MIN_10_EXP` หรือ `LDBL_MIN_10_EXP` สำหรับประเภทลอย
`max_exponent`	`int`	เป็นค่าจำนวนเต็มสูงสุดที่`รัศมี`ยกขึ้นเพื่อ`(max_exponent-1)`สร้างตัวเลขทศนิยมที่ จำกัด ที่สามารถแสดงได้ เทียบเท่ากับ `FLT_MAX_EXP`, `DBL_MAX_EXP` หรือ `LDBL_MAX_EXP` สำหรับประเภทลอย
`max_exponent10`	`int`	เป็นค่าจำนวนเต็มสูงสุดเช่น 10 ยกกำลังนั้นจะสร้างเลขทศนิยม จำกัด ที่เป็นมาตรฐาน เทียบเท่ากับ `FLT_MAX_10_EXP`, `DBL_MAX_10_EXP` หรือ `LDBL_MAX_10_EXP` สำหรับประเภทลอย
`has_infinity`	`bool`	`true` ถ้าประเภทมีการแทนค่าอินฟินิตี้บวก
`has_quiet_NaN`	`bool`	`true` หากประเภทมีการแสดงสำหรับ "Not-a-Number" แบบเงียบ (ไม่ใช่สัญญาณ)
`has_signaling_NaN`	`bool`	`true` หากประเภทมีการแสดงสัญญาณ "Not-a-Number"
`has_denorm`	`float_denorm_style`	มันเป็นค่าที่ไม่เป็นมาตรฐาน (การแทนค่าด้วยจำนวนตัวแปรของบิตยกกำลัง) ประเภทอาจมีค่า enum ใด ๆ ต่อไปนี้ - `denorm_absent`หากไม่อนุญาตให้มีค่าที่ผิดปกติ `denorm_present`หากอนุญาตให้มีค่าที่ผิดปกติ `denorm_indeterminate`หากไม่ทราบแน่ชัดในเวลาคอมไพล์
`has_denorm_loss`	`bool`	`true`หากตรวจพบการสูญเสียความแม่นยำเป็นการสูญเสียการทำให้เป็นปกติแทนที่จะเป็นผลลัพธ์ที่ไม่แน่นอน
`อินฟินิตี้ ()`	`ที`	มันแสดงถึงอินฟินิตี้บวกถ้ามี
`quiet_NaN ()`	`ที`	มันแสดงถึงความเงียบ (ไม่ใช่การส่งสัญญาณ) "Not-a-Number"ถ้ามี
`signaling_NaN ()`	`ที`	ซึ่งแสดงถึงการส่งสัญญาณว่า "Not-a-Number"หากมี
`denorm_min ()`	`ที`	ค่าที่ผิดปกติที่เป็นบวกขั้นต่ำ มันเป็นชนิดไม่อนุญาตให้ค่า denormalized: `min()`เช่นเดียวกับ
`is_iec559`	`bool`	`true` หากประเภทเป็นไปตามมาตรฐาน IEC-559 / IEEE-754 ประเภท IEC-559 มีอยู่เสมอ `has_infinity`, `has_quiet_NaN` และ `has_signaling_NaN`ตั้งค่าเป็น`true`; และ`อินฟินิตี้`, `quiet_NaN` และ `signaling_NaN` ส่งคืนค่าที่ไม่ใช่ศูนย์
`is_bounded`	`bool`	`true` หากชุดของค่าที่แสดงโดยประเภทนั้น จำกัด
`is_modulo`	`bool`	`true`ถ้าประเภทเป็นโมดูโล ประเภทคือโมดูโลหากสามารถเพิ่มจำนวนบวกสองจำนวนและมีผลลัพธ์ที่ล้อมรอบเป็นตัวเลขที่สามที่น้อยกว่า
`กับดัก`	`bool`	`true` หากใช้กับดักสำหรับประเภท
`tinyness_before`	`bool`	`true` หากตรวจพบความเล็กก่อนปัดเศษ
`round_style`	`float_round_style`	มันเป็นลักษณะการปัดเศษ ประเภทอาจมีค่า enum ใด ๆ ต่อไปนี้ - `round_toward_zero`ถ้ามันปัดเศษเข้าหาศูนย์ `round_to_nearest`ถ้ามันปัดเศษเป็นค่าที่แสดงได้ใกล้เคียงที่สุด `round_toward_infinity`ถ้ามันปัดไปทางอินฟินิตี้ `round_toward_neg_infinity`ถ้ามันปัดไปทางลบอินฟินิตี้ `round_indeterminate`หากรูปแบบการปัดเศษไม่สามารถกำหนดได้ในเวลาคอมไพล์

สำหรับประเภทข้างต้นทั้งหมดที่ไม่ใช่ประเภทเลขคณิตพื้นฐานจะใช้นิยามเทมเพลตเริ่มต้น -

C ++ 98

template <class T> class numeric_limits {
   public:
      static const bool is_specialized = false;
      static T min() throw();
      static T max() throw();
      static const int digits = 0;
      static const int digits10 = 0;
      static const bool is_signed = false;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = 0;
      static T epsilon() throw();
      static T round_error() throw();

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      static T infinity() throw();
      static T quiet_NaN() throw();
      static T signaling_NaN() throw();
      static T denorm_min() throw();

      static const bool is_iec559 = false;
      static const bool is_bounded = false;
      static const bool is_modulo = false;

      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
};

C ++ 11

template <class T> class numeric_limits {
   public:
      static constexpr bool is_specialized = false;
      static constexpr T min() noexcept { return T(); }
      static constexpr T max() noexcept { return T(); }
      static constexpr T lowest() noexcept { return T(); }
      static constexpr int digits = 0;
      static constexpr int digits10 = 0;
      static constexpr bool is_signed = false;
      static constexpr bool is_integer = false;
      static constexpr bool is_exact = false;
      static constexpr int radix = 0;
      static constexpr T epsilon() noexcept { return T(); }
      static constexpr T round_error() noexcept { return T(); }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm = denorm_absent;
      static constexpr bool has_denorm_loss = false;
      static constexpr T infinity() noexcept { return T(); }
      static constexpr T quiet_NaN() noexcept { return T(); }
      static constexpr T signaling_NaN() noexcept { return T(); }
      static constexpr T denorm_min() noexcept { return T(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = false;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = false;
      static constexpr bool tinyness_before = false;
};