对于开发者来说，像基本数据类型这种比较基础的知识应该是不被担忧的，但是前段时间检查项目代码时发现居然有tag越界的情况。

简单说一下tag越界的危害：

viewWillAppear：方法中展示view，并给view一个tag值；viewWillDisappear：方法中remove这个view，假设这里必须通过tag值来找到需要被remove的view。

一旦tag越界，那么在remove的时候，我们就无法找到目标view。如果反复进入这个页面的话，那么就会只有创建，没有释放。视觉上：视图重复；内存上：消耗增加。

当然，这里还需要注意的是，对基本数据类型的赋值一定要考虑当前系统是32位的，还是64的。开发必须严谨，不能走大众路线。

数据类型取值范围还是看所占内存大小，首先分别在32位和64位机器上打印一下它们所占的内存大小：

NSLog(@"char: %lu",sizeof(char));
NSLog(@"int:%lu",sizeof(int));
NSLog(@"short:%lu",sizeof(short));
NSLog(@"long: %lu",sizeof(long));
NSLog(@"unsigned int:%lu",sizeof(unsignedint));
NSLog(@"unsigned short:%lu",sizeof(unsignedshort));
NSLog(@"unsigned long: %lu",sizeof(unsignedlong));
NSLog(@"long long:%lu",sizeof(longlong));
NSLog(@"NSInteger: %lu",sizeof(NSInteger));
NSLog(@"NSUInteger:%lu",sizeof(NSUInteger)); 
/*
 32位机器打印结果：
 char: 1
 int:  4
 short:2
 long: 4
 unsigned int:  4
 unsigned short:2
 unsigned long: 4
 long long:     8
 NSInteger: 4
 NSUInteger:4
 */
/*
 64位机器打印结果：
 char: 1
 int:  4
 short:2
 long: 8
 unsigned int:  4
 unsigned short:2
 unsigned long: 8
 long long:     8
 NSInteger: 8
 NSUInteger:8
 */

基于计算机的二进制计数法，这里来看一下计算规则：1Byte = 8bit，对于无符号数：没有符号位，也就是8位全部可以表示数据，并且最小值是0，取值范围：0 ~ 2^{8；对于有符号数：1位符号位，这样只有7位用来表示数据，取值范围：-2}7 ~ 2^7-1；然后分别在32位和64位机器上打印一下它们的最大最小值：

    int max_int = pow(2, 31) - 1;
    int min_int = - pow(2, 31);
    NSLog(@"int: max_int:%d  min_int:%d", max_int, min_int);
    //32:int: max_int:2147483647  min_int:-2147483648
    //64:int: max_int:2147483647  min_int:-2147483648
    
    short max_short = pow(2, 15) - 1;
    short min_short = - pow(2, 15);
    NSLog(@"short: max_short:%d  min_short:%d", max_short, min_short);
    //32:short: max_short:32767  min_short:-32768
    //64:short: max_short:32767  min_short:-32768
    
    long max_long = powl(2, 63) - 1;
    long min_long = - powl(2, 63);
    NSLog(@"long: max_long:%ld  min_long:%ld", max_long, min_long);
    //32:long: max_long:2147483647  min_long:-2147483648
    //64:long: max_long:9223372036854775807  min_long:-9223372036854775808
    
    unsigned int max_uint = pow(2, 32) - 1;
    unsigned int min_uint = - pow(2, 32);
    NSLog(@"unsigned int: max_uint:%u  min_uint:%u", max_uint, min_uint);
    //32:unsigned int: max_uint:4294967295  min_uint:0
    //64:unsigned int: max_uint:4294967295  min_uint:0
    
    unsigned short max_ushort = pow(2, 16) - 1;
    unsigned short min_ushort = - pow(2, 16);
    NSLog(@"unsigned short: max_ushort:%u  min_ushort:%u", max_ushort, min_ushort);
    //32:unsigned short: max_ushort:65535  min_ushort:0
    //64:unsigned short: max_ushort:65535  min_ushort:0
    
    unsigned long max_ulong = powl(2, 64) - 1;
    unsigned long min_ulong = - powl(2, 64);
    NSLog(@"unsigned long: max_ulong:%lu  min_ulong:%lu", max_ulong, min_ulong);
    //32:unsigned long: max_ulong:4294967295  min_ulong:0
    //64:unsigned long: max_ulong:18446744073709551615  min_ulong:9223372036854775808
    
    long long max_llong = powl(2, 63) - 1;
    long long min_llong = - powl(2, 63);
    NSLog(@"long long: max_llong:%lld  min_llong:%lld", max_llong, min_llong);
    //32:long long: max_llong:9223372036854775807  min_llong:-9223372036854775808
    //64:long long: max_llong:9223372036854775807  min_llong:-9223372036854775808
    
    NSInteger max_integer = powl(2, 63) - 1;
    NSInteger min_integer = - powl(2, 63);
    NSLog(@"NSInteger: max_integer:%ld, min_integer:%ld", max_integer, min_integer);
    //32:NSInteger: max_integer:2147483647, min_integer:-2147483648
    //64:NSInteger: max_integer:9223372036854775807, min_integer:-9223372036854775808
    
    NSUInteger max_uinteger = powl(2, 64) - 1;
    NSUInteger min_uinteger = - powl(2, 64);
    NSLog(@"NSUInteger: max_uinteger:%lu, min_uinteger:%lu", max_uinteger, min_uinteger);
    //32:NSUInteger: max_uinteger:4294967295, min_uinteger:0
    //64:NSUInteger: max_uinteger:18446744073709551615, min_uinteger:9223372036854775808

注：展开NSInteger和NSUInteger后发现，他们分别对应int和unsigned int:

NSInteger&NSUInteger的实质.png

根据输出结果发现unsigned long（NSUInteger）类型值的最小值并不是0。这是因为无符号长整型数一旦给了负值，会按无符号数字来处理。
例如-1，会被默认成没有符号位的所有二进制位均为1，那么打印的值为：18446744073709551615。
例如二进制数1111表示15，如果最多用4位二进制数表示-pow(2, 4)，写法为： -(1111+1)。最多4位2进制数的计算过程：-(1111+1) --> -(0000) --> 1000，那么此时这个数为十进制的8。
所以- powl(2, 64)的64位二进制数全为1的值为18446744073709551615，那么powl(2, 64)的二进制值就是64位均为0的二进制数，那么-powl(2, 64)的二进制数为第一位为1，剩余63位均为0的二进制数，转化成十进制数值为：9223372036854775808。
结论：这里的输出值没有错，但不是实际意义上的最小值，无符号长整型的最小值应该是0。

另外对于float和double存储空间的打印，32位和64位均为：

    NSLog(@"float:%lu", sizeof(float));
    NSLog(@"double:%lu", sizeof(double));
    //float:4
    //double:8

对于float和double的范围是由指数的位数来决定的。
float的指数位有8位，而double的指数位有11位，分布如下：

浮点数据分布.png

根据上表可以看到，float的指数范围为-127_{+128，而double的指数范围为-1023}+1024，并且指数位是按补码的形式来划分的。其中负指数决定了浮点数所能表达的绝对值最小的非零数；而正指数决定了浮点数所能表达的绝对值最大的数，也即决定了浮点数的取值范围。
float的范围为-2^128 ~ +2^128，也即-3.40E+38 ~ +3.40E+38；double的范围为-2^1024 ~ +2^1024，也即-1.79E+308 ~ +1.79E+308。
这里还要说下float和double的精度：
float和double的精度是由尾数的位数来决定的。浮点数在内存中是按科学计数法来存储的，其整数部分始终是一个隐含着的“1”，由于它是不变的，故不能对精度造成影响。
float：2^23 = 8388608，一共七位，这意味着最多能有7位有效数字，但绝对能保证的为6位，也即float的精度为6~7位有效数字；
double：2^52 = 4503599627370496，一共16位，同理，double的精度为15~16位。

这样就得到如下表格：

基本数据类型取值范围.png

欢迎交流_.