In C/C ++, int, long, double, and char Types indicate the range (maximum and minimum values) and doublechar

In C/C ++, int, long, double, and char Types indicate the range (maximum and minimum values) and doublechar
[Cpp]View plaincopy

1. # Include <iostream>
2. # Include <string>
3. # Include <limits>
4. Using namespace std;
6. Int main ()
7. {
8. Cout <"type: \ t "<" ************* size *************** "<endl;
9. Cout <"bool: \ t" <"Bytes:" <sizeof (bool );
10. Cout <"\ t maximum value:" <(numeric_limits <bool >:: max )();
11. Cout <"\ t minimum value:" <(numeric_limits <bool>: min) () <endl;
12. Cout <"char: \ t" <"Bytes:" <sizeof (char );
13. Cout <"\ t maximum value:" <(numeric_limits <char>: max )();
14. Cout <"\ t minimum value:" <(numeric_limits <char >:: min) () <endl;
15. Cout <"signed char: \ t" <"Bytes:" <sizeof (signed char );
16. Cout <"\ t maximum value:" <(numeric_limits <signed char >:: max )();
17. Cout <"\ t minimum value:" <(numeric_limits <signed char>: min) () <endl;
18. Cout <"unsigned char: \ t" <"Bytes:" <sizeof (unsigned char );
19. Cout <"\ t maximum value:" <(numeric_limits <unsigned char >:: max )();
20. Cout <"\ t minimum value:" <(numeric_limits <unsigned char>: min) () <endl;
21. Cout <"wchar_t: \ t" <"Bytes:" <sizeof (wchar_t );
22. Cout <"\ t maximum value:" <(numeric_limits <wchar_t>: max )();
23. Cout <"\ t minimum value:" <(numeric_limits <wchar_t>: min) () <endl;
24. Cout <"short: \ t" <"Bytes:" <sizeof (short );
25. Cout <"\ t maximum value:" <(numeric_limits <short >:: max )();
26. Cout <"\ t minimum value:" <(numeric_limits <short>: min) () <endl;
27. Cout <"int: \ t" <"Bytes:" <sizeof (int );
28. Cout <"\ t maximum value:" <(numeric_limits <int>: max )();
29. Cout <"\ t minimum value:" <(numeric_limits <int>: min) () <endl;
30. Cout <"unsigned: \ t" <"Bytes:" <sizeof (unsigned );
31. Cout <"\ t maximum value:" <(numeric_limits <unsigned>: max )();
32. Cout <"\ t minimum value:" <(numeric_limits <unsigned>: min) () <endl;
33. Cout <"long: \ t" <"Bytes:" <sizeof (long );
34. Cout <"\ t maximum value:" <(numeric_limits <long>: max )();
35. Cout <"\ t minimum value:" <(numeric_limits <long>: min) () <endl;
36. Cout <"unsigned long: \ t" <"Bytes:" <sizeof (unsigned long );
37. Cout <"\ t maximum value:" <(numeric_limits <unsigned long>: max )();
38. Cout <"\ t minimum value:" <(numeric_limits <unsigned long>: min) () <endl;
39. Cout <"double: \ t" <"Bytes:" <sizeof (double );
40. Cout <"\ t maximum value:" <(numeric_limits <double >:: max )();
41. Cout <"\ t minimum value:" <(numeric_limits <double >:: min) () <endl;
42. Cout <"long double: \ t" <"Bytes:" <sizeof (long double );
43. Cout <"\ t maximum value:" <(numeric_limits <long double >:: max )();
44. Cout <"\ t minimum value:" <(numeric_limits <long double >:: min) () <endl;
45. Cout <"float: \ t" <"Bytes:" <sizeof (float );
46. Cout <"\ t maximum value:" <(numeric_limits <float >:: max )();
47. Cout <"\ t minimum value:" <(numeric_limits <float>: min) () <endl;
48. Cout <"size_t: \ t" <"number of bytes:" <sizeof (size_t );
49. Cout <"\ t maximum value:" <(numeric_limits <size_t>: max )();
50. Cout <"\ t minimum value:" <(numeric_limits <size_t>: min) () <endl;
51. Cout <"string: \ t" <"Bytes:" <sizeof (string) <endl;
52. // <"\ T maximum value:" <(numeric_limits <string>: max) () <"\ t minimum value:" <(numeric_limits <string> :: min) () <endl;
53. Cout <"type: \ t "<" ************* size *************** "<endl;
54. Return 0;
55. }

/* Running result analysis:

The above results are quite clear. Here are some additional notes:

Concept and integer: The arithmetic types that indicate integers, characters, and boolean values are collectively called integer types ).

About the signed and unsigned types: integer int, stort, and long are both signed by default. To obtain the unsigned type, you must specify this type as unsigned, for example, unsigned long. The unsigned int type can be abbreviated as unsigned. That is to say, the unsigned int type is unsigned without any other type specifiers.

One byte indicates eight bits, that is, 1 byte = 8 bits;

Int: 4 byte = 32 bit signed range: 2 ^ 31-1 ~ -2 ^ 31: 2147483647 ~ -2147483648 unsigned range: 2 ^ 32-1 ~ 0 means: 4294967295 ~ 0

Long: 4 byte = 32 bit same as int type

Double: 8 byte = 64 bit range: 1.79769e + 308 ~ 2.22 507e-308

Long double: 12 byte = 96 bit; value range: 1.18973e + 4932 ~ 3.3621 e-4932

Float: 4 byte = 32 bit range: 3.40282e + 038 ~ 1.17549e-038

The maximum values of int, unsigned, long, unsigned long, and double values can only be expressed as 1 billion. That is, they indicate no more than 10 decimal digits, that is, all 9-digit integers can be saved. Short can only represent five digits;

 

In addition, for floating point, there is basically no error in using the double type. In the float type, the implicit loss of precision cannot be ignored, and the cost of the second double precision calculation can be ignored relative to the single precision. In fact, on some machines, the double type is much faster than the float type. The float type can only ensure 6 Valid digits, while the double type can ensure at least 15 valid digits (digits after the decimal point). The precision provided by the long double type is usually unnecessary, it also bears additional operation costs.

Double is an 8-byte 64-bit, where decimal places occupy 52 digits, 2-^ 52 = 2.2204460213503130808472633361816e-16, and the magnitude is 10 ^-16, therefore, it can ensure all the precision of 2 ^-15.

On some machines, the running price of long TYPE calculation is much higher than that of int type calculation, therefore, before calculating the type, you must first understand the program details and compare the actual runtime performance cost of the long and int types.