基本数据类型取值范围

1、JAVA基本数据类型取值范围

JAVA的数据类型分为两大种：基本数据类型（值类型）和包装类型（引用数据类型）。基本数据类型不是对象，不能调用toString、hashCode、getClass、equals等方法。

JAVA共有八种基本数据类型，对应八种包装类型：

byte、short、int、long、float、double、char、boolean
Byte、Short、Integer、Long、Float、Double、Char、Boolean

整型：

byte	Byte	[-2^7~2^7-1]	1个字节		8位35B
short	Short	[-2^15~2^15-1]	2<span style="font-family: Arial, Helvetica, sans-serif;">个字节			16位35S
int	Integer	[-2^31~2^31-1]	4个字节		32位35
long	Long	[-2^63~2^63-1]	8个字节		64位35L

浮点型：

float	Float	[1.401298e-45~3.402823e+38]	4个字节
double	Double	[4.9000000e-324~1.797693e+308]	8个字节

float占用4个字节，和int是一样，也就是32bit。
格式化表示：
第1个bit表示符号,0表示正数,1表示负数；
第2-9个bit表示指数，一共8为，为了同时表示正数和负数，表示范围为(-127到128)，另外全0和全1作为特殊处理，所以直接表示-126到127。
第10-32个bit表示小数，一共23位，这里23位表示了24位的数字，因为有一个默认的前导1(只有二进制才有这个特性)。
所以格式化float的取值范围为(-1)^(sign) * 1.f * 2^(exponent)，其中sign是符号位,f是23bit的小数部分,exponent是指数部分，最后表示范围为2^(-126) ~ (1+1-2^(-23)) * 2^127 = 2^128*(1-2^(-24)) ≈ 2^128-1。
非格式化表示：
当指数部分全0而且小数部分不全0时表示的是非规格化的浮点数，因为这里默认没有前导1，而是0。
所以非格式化float取值范围0.f * 2^(-126)，表示范围位 2^(-(23+126)) ~ (1-2^(-23)) * 2^(-126)。
其他特殊表示：
1.当指数部分和小数部分全为0时，表示0值，有+0和-0之分(符号位决定)，0x00000000表示正0，0x80000000表示负0。
2.指数部分全1，小数部分全0时，表示无穷大，有正无穷和负无穷，0x7f800000表示正无穷，0xff800000表示负无穷。
3.指数部分全1，小数部分不全0时，表示NaN，分为QNaN和SNaN，Java中都是NaN。
综上，float的取值范围为 2^(-149)~2^128-1（这里只取了正值），即Float.MIN_VALUE和Float.MAX_VALUE。
double和float类似：第2-11位共10位表示指数，第12-64共52位表示小数。其取值范围为： 2^(-1074)~2^1024-1（这里只取了正值），即Double.MIN_VALUE和Double.MAX_VALUE。

字符型：
char Character 2个字节
用于存放字符的数据类型，占用2个字节，采用unicode编码，它的前128字节编码与ASCII兼容
字符的存储范围在\u0000~\uFFFF，在定义字符型的数据时候要注意加' '，比如 '1'表示字符'1'而不是数值1

布尔型：
boolean Boolean
只有两个值，true和false

2、PYTHON基本数据类型

PYTHON有五类基本内置类型：数值（bool、int、long、float、complex），字符串（str），元组（tuple），列表（list），字典（dict）。这里主要记录下五个数值类型，这些类型是不可变的，就是说整数对象一旦创建，其值便不可更改。相反，系统将创建新的简单类型对象并将其赋值给变量。通过 Python id 函数，可以查看基本 PyObject 标识的变更方式。

>>> i = 100
>>> id(i)
8403284
>>> i = 101
>>> id(i)
8403296

此方法看似容易丢失对象，会导致内存泄漏。但是，Python 像 C# 和 Java 一样， 使用了垃圾回收功能，以释放用于保存不再引用的对象的内存，如上例中用于保存 100 的整数对象。

Python 中最简单的内置类型是 bool 类型，该类型包括的对象仅可能为 True 或 False：

>>> b = True
>>> type(b)
<type 'bool'>
>>> id(b)
1041552

因为只有两个可能值，所以布尔类型是惟一的。Python 解释器提供这仅有的（也是必需的）两个 bool 对象：True 和 False。 在任何时候，在 Python 程序需要这些对象时，变量只能相应地引用其中一个值。清单 5 显示 bb 变量如何具有同一个 id，不管您直接赋予它 b 变量的值还是直接赋予它 True 对象。

>>> b = True
>>> id(b)
1041552
>>> bb = b
>>> id(bb)
1041552
>>> bb = True
>>> id(bb)
1041552

很多程序利用布尔表达式，Python 提供一整套布尔比较和逻辑运算，详细信息请分别参见表 1 和表 2。

表 1：

运算符		描述					示例
<		小于					i < 100
<=		小于等于				i <= 100
>		大于					i > 100
>=		大于等于				i >= 100
==		相等					i == 100
!=		不相等（另外使用 <>）			i != 100

补充一点， 表 1 中列出的运算符优先级都一样，除非将表达式置于括号中，否则按从左到右的顺序应用。

表 2：

运算符		描述					示例
not		逻辑非					not b
and		逻辑与					(i <= 100) and (b == True)
or		逻辑或					(i < 100) or (f > 100.1)

逻辑运算符的优先级低于单独的比较运算符，这一点意义重大，因为必须先计算比较运算符，然后才能计算逻辑运算符。逻辑运算符的实际优先级就是表 2 中罗列这些运算符的顺序。

在 Python 中，关于 or 和 and 逻辑运算符有意思的是， 它们都是快捷运算符。简言之，如果给定表达式 x or y，则仅当 x 为 False 时才会计算 y。同样地，如果给定表达式 x and y，则仅当 x 为 True 时，才会计算 y(也就是说,python中的and等同于其他语言中的&&,python中的or等同其他语言的||)。此功能可以增强表达式求值的性能（尤其是针对长的或复杂的表达式），然而对于习惯于从其他语言学来的不同规则的程序员而言，则容易犯错。

Python 中其他四个简单的内置类型都是数值类型：int、long、float 和 complex。在程序中，数值类型很常见，不管使用的是什么语言。Python 对算术运算提供完整支持，包括加法、减法、乘法和除法（参见表 3）。

表 3：

运算符		描述		示例
*		乘		i * 100
/		除		i / 100
//		整除		i // 100
%		取余		i % 100
+		加		i + 100
-		减		i - 100

乘法和除法运算符（表 3 中列出的前四个）具有高于加法和减法的优先级。如前所述，您可以通过使用括号分组子表达式，将其分离出来以提高优先级。

Python 与 Java 语言不同，Java 语言通常定义允许的数值类型的范围，而 Python 在这一点上更像 C，因为它的类型范围是依赖于平台的。您可以使用 int 和 long 两种类型来保存整数值，它们的不同点在于 int 是一种 32 位的整数值。因而，在多数平台上它被限制为只能保存从 -2^31 到 2^31 - 1 之间的值（在64位系统上，整型的位宽通常为64位，取值范围为-2^63～2^63-1）。与此相反，长整数类型的精度不受限，仅计算机内存对它有影响。要通知 Python 应该按照长类型处理整数，只需将 L 附加到数字的末尾，如 100L。在 Python 中，浮点值始终是按双精度处理的；因此 Python 的 float 类型对应于 C 类语言中的双精度。
与数值类型相关的其他两个重点是常量（如上例中的 100，只是明确表达的数字）和位运算。程序员一般在十进制系统（以 10 为基数）中工作。但是，有时其他系统也相当有用，尤其是我们知道计算机是基于二进制的。Python 可以提供对八进制（以 8 为基数）和十六进制（以 16 为基数）数字的支持。要通知 Python 应该按八进制数字常量处理数字，只需将零附加在前面。将一个零加上一个 x 附加在数字的前面是告诉 Python 按十六进制数值常量处理数字，如以下代码所示：

>>> print 127    # Using decimal literal
127
>>> print 0177   # Using octal literal
127
>>> print 0x7F   # Using hexadecimal literal
127

当您具有容易的方式来表达数值常量时，尤其是十六进制，就可以容易地构建对应于特定测试用例的标志，这是一种常见的编程技术。例如，一个 32 位的整数可以存储 32 个标志值。使用位测试，可以容易地测试标志变量上的特定标志。Python 中位运算的完整列表如表 4 所示。

表 4：

运算符		描述		示例
~		按位求补	~b
<<		向左位移	b << 1
>>		向右位移	b >> 1
&		按位和		b & 0x01
^		按位异或	b ^ 0x01
|		按位或		b | 0x01

至此，您可能想知道不同数值类型在单个表达式中混合出现的时候怎么办。简单的答复是，Python 会根据需要将表达式中的所有操作数转换为最复杂的操作数的类型。复杂度的顺序是：int、long、float 和 complex（复数），下面是一个简单的示例：

>>> 1 / 3
0
>>> 1.0 / 3
0.33333333333333331
>>> 1.0 // 3
0.0
>>> 1 % 3
1
>>> 1.0 % 3
1.0

尽管 Python 会与您预期的一样转换操作数，但是语言并不基于运算符转换操作数，如 1/3 示例中所示，其计算结果为整数。如果要强制取得浮点结果，则必须确保操作数中至少有一个为浮点类型。
最后一种类型 complex 可能是大多数程序员难以识别的，因为它不是其他编程语言中常见的内置数据类型。而对于工程师和科学家来说，复数却是个司空见惯的概念。从形式上讲，复数 具有实部和虚部两个部分，都由 Python 中的 float 类型来表示。虚数 是 -1 的平方根的倍数，用 i 或 j 表示 —— 取决于您被培养为科学家还是工程师。在 Python 中，复数的虚部被表示为 j：

>>> c = 3.0 + 1.2j
>>> print c
(3+1.2j)
>>> print c.real, c.imag
3.0 1.2

本例是一个实部为 3.0 和虚部为 1.2 的复数。注意，通过使用复杂对象的 real 和 imag 属性，即可访问复数的不同部分。

到此为止，我已经介绍了 Python 只处理对象类型，然而示例中好像并没有什么对象。最后还有一个问题，构造函数在哪里？对于简单的内置数据类型，Python 替您做了大量的工作。不过，构造函数还在那里（其名称与相关数据类型的名称相同），如果您愿意，可以直接使用它们，如下所示：

>>> b = bool(True)
>>> i = int(100)
>>> l = long(100)
>>> f = float(100.1)
>>> c = complex(3.0, 1.2)
>>> print b, i, l, f, c

3、C++基本数据类型取值范围

数据类型关键字	字节数	数值范围
char		1	-2^7~2^7-1
unsigned char	1	0~2^8-1
short		2	-2^15~2^15-1
unsigned short	2	0~2^16-1
long		4	-2^31~2^31-1
unsigned long	4	0~2^32-1
int		4	同long
unsigned int	4	同unsigned long
float		4	1.2E-38~3.4E381
double		8	2.2E-308~1.8E3082
bool		1	true或false