C语言开发总结（十七）

浅析为什么char类型的范围是 —128~+127

 在C语言中， signed char 类型的范围为-128~127,每本教科书上也这么写，但是没有哪一本书上（包括老师）也不会给你为什么是-128~127，这个问题貌似看起来也很简单容易， 以至于不用去思考为什么，不是有一个整型范围的公式吗：  -2^(n-1)~2^(n-1)-1   n为整型的内存占用位数，所以int类型32位 那么就是 -(2^31)~2^31 -1 即

   -2147483648~2147483647,但是为什么最小负数绝对值总比最大正数多1 ，这个问题甚至有的工作几年的程序员都模棱两可，因为没有深入思考过，只知道书上这么写。。于是，我不得不深入思考一下这个被许多人忽视的问题。。

    对于无符号整数，很简单，全部位都表示数值，比如 char型，8位，用二进制表示为0000 0000 ~ 1111 1111

  1111 1111 最大即为十进制255,所以 unsigned char 的范围为0~ 255，在这里普及一下2进制转十进制的方法， 二进制每一位的数值乘以它的位权(2^(n-1),n为自右向左的位),再相加，可得到十进制数，比如 ：

1111 1111 =1*2^7+1*2^6+1*2^5+1*2^4+1*2^3+1*2^2+1*2^1+1*2^0=127  。

   但是对于有符号整数，二进制的最高位表示正负，不表示数值，最高位为0时表示正数，为1时表示负数，这样一来，能表示数值的就剩下(n-1)位了，比如 char a= -1;   那么二进制表示就为 1 0000001,  1 表示为0 0000001 ,所以signed char 型除去符号位剩下的7位最大为1111 111 =127，再把符号加上，0 1111111=127 ，1 1111111= -127，范围应该为 -127~127 ，同理int类型也一样，但是问题出来了，教科书上是-128~127 啊，下面就剖析一下这个惊人的奇葩。。。

    再普及一下计算机内部整数存储形式，大家都知道计算机内部是以二进制来存贮数值的，无符号整数会用全部为来存储，有符号的整数，最高位当做符号位 ，其余为表示数值，这样貌似合理， 却带来一个麻烦，当进行加法时，1+1

       0000 0001

+     0000 0001

—————————

       0000  0010    ………………2 

当相减时 1-1=?  由于计算机只会加法不会减法，它会转化为1+(-1) ,因此

      0000 0001

+    1000 0001

____________________

          1000 0010     …………… -2    ，1-1= -2?  这显然是不对了，所以为了避免减法运算错误，计算机大神们发明出了反码，直接用最高位表示符号位的叫做原码， 上面提到的二进制都是原码形式，反码是原码除最高位其余位取反，规定：正数的反码和原码相同，负数的反码是原码除了符号位，其余为都取反，因此-1 的源码为 1 0000001 ，反码为 1 1111110, 现在再用反码来计算 1+(-1)

      0000 0001

+    1111 1110

————————

      1111 1111       …………再转化为原码就是 1000 0000 = -0  ，虽然反码解决了相减的问题，却又带来一个问题，-0 ，既然0000 0000 表示 0，那么就没有 -0 的必要， 出现 +0= -0=0 ，一个0 就够了，为了避免两个0的问题，计算机大师们又发明了补码，补码规定： 整数的补码是其本身，负数的补码为其反码加一 ，所以，负数转化为反码需两个步骤， 第一，先转化为反码，第二： 把反码加一。。这样 -1 的补码为 1111 1111    ，1+(-1)

     0000 0001

+   1111 1111

________________

  1  0000 0000  ……………………  这里变成了9位，由于char 为8位，最高位1 被丢弃 结果为0 ，运算正确

 

  再看， -0 ：原码 1000 0000 的补码为1 0000 0000 ，由于char 是 八位 ，所以取低八位00000000,   +0 ：原码为0000 00000 ，补码为也为 0000 0000 ，虽然补码0都是相同的，但是有两个0 ，既然有两个0 ，况且0既不是正数，也不是负数， 用原码为0000 0000 表示就行了， 这样一来，有符号的char ,原码都用来表示-127~127 之间的数了，唯独剩下原码1000 0000 没有用，用排列组合也可以算出来，0？？？？？？？，能表示2^7=128个数，刚好是0~127, 1???????,也能表示128个数，总共signed char 有256 个数，这与-127~127 中间是两个0 刚好吻合。。现在再来探讨一下关于剩下的那个1000 0000，

既然-127 ~0~ 127都有相应的原码与其对应，那么1000 0000 表示什么呢，当然是-128了，为什么是-128呢，网上有人说-0即1000 0000 与128的补码相同，所以用1000 0000表示-128,，这我实在是不敢苟同，或者说-128没有原码，只有补码1000 0000,胡扯，既然没有原码何来补码，还有说-128的原码与-0(1000 0000)的原码相同，所以可以用1000 0000表示-128，我只能说，回答的不要那么牵强， 原码1000 0000 与-128的原码实际上是不同的， 但为什么能用它表示-128进行运算，如果不要限制为char 型（即不要限定是8位），再来看，-128的原码：1 1000 0000 ，9位，最高位符号位，再算它的反码：1 0111 1111，进而，补码为： 1 1000 0000,这是-128的补码，发现和原码一样, 1 1000 0000和1000 0000 相同?如果说一样的人真是瞎了眼了，所以，-128的原码和-0(1000 000)的原码是不同的，但是在char 型中，是可以用1000 000 表示-128的，关键在于char 是8位，它把-128的最高位符号位1 丢弃了，截断后-128的原码为1000 000 和-0的原码相同，也就是说

1000 0000  和-128丢弃最高位后余下的8位相同，所以才可以用-0 表示-128，这样，当初剩余的-0(1000 0000)，被拿来表示截断后的-128,因为即使截断后的-128和char 型范围的其他数(-127~127)运算也不会影响结果， 所以才敢这么表示-128。

   比如 -128+(-1)

     1000 0000  ------------------丢弃最高位的-128

+     1111  1111   -----------------   -1

________________

   10111  1111    ------------------char 取八位，这样结果不正确，不过没关系 ，结果-129本来就超出char型了，当然不能表示了。

    比如 -128+127

     1000 0000

  + 0111 1111

————————

     1111 1111 --------------  -1 结果正确， 所以，这就是为什么能用 1000 0000表示-128的原因。

  从而也是为什么char 是-128~127，而不是-127~127 ，short int 同样如此 -32768~32767  因为在16位中，-32768为原码为17位，丢弃最高位剩下的16为- 0 的原码相同。。。。

     还有一个问题：

     既然-128最高位丢弃了。那么

     char a=-128;  //在内存中以补码1 1000 0000 存储，但由于是char ,所以只存储 1000 0000

     printf("%d",a); //既然最高位丢弃了，输出时应该是1000 000 的原码的十进制数-0 ，但为什么能输出-128呢。

     还能打印出-128；

     我猜想是计算机内部的一个约定，就像float一样 ，能用23位表示24位的精度 ，因为最高位默认为1，到时候把23位取出再加 1便可。

    -128也是同样的原理，当数据总线从内存中取出的是1000 000 ，CPU会给它再添最高一位，变为1 1000 0000 这样才能转化为

   -128输出，不然1000 0000 如何输出？这当然是我的一种推断，具体怎么实现还得问CPU的设计者了。。。。

     再看一个例子：

      char a=-129;

      printf("%d",a)  ;    会输入多少？？    结果为127 ，为什么呢？ 

      -129在补码为10 0111 1111 只取后八位存储，即 0111 111 这个值刚好是127了，同理-130 截断后为126.....

如此按模轮回，关于模就先不探讨了。。

      那么

      unsigned  char a=  -1;

     if( 1>a)   printf("大于");

      else  

          printf("小于");

      结果是什么呢？  出人意料的是：  小于，而不是大于，猫腻在你哪呢，还是存储问题：

     a为unsigned 无符号， 它的八位都用来存储数值， 没有符号位，编译器把 -1 转换为补码为 1111 1111,但由于是无符号，计算机会把 1111 11111 当做是无符号来对待 ，自然就是 2^8 -1  = 255 了，所以相当于是if( 1>255) 肯定是

 printf("小于");了。。。

      。。。。。。。。。。。

     好了，就说到这儿吧。。。。。。。。

 

float 精度探究

最近一段时间看到版上关于 C++ 里浮点变量精度的讨论比较多，那么我就给对这个问题有疑惑的人详细的讲解一下 intel 的处理器上是如何处理浮点数的。为了能更方便的讲解，我在这里只以 float 型为例，从存储结构和算法上来讲， double 和 float 是一样的，不一样的地方仅仅是 float 是 32 位的， double 是 64 位的，所以 double 能存储更高的精度。还要说的一点是文章和程序一样，兼容性是有一定范围的，所以你想要完全读懂本文，你最好对二进制、十进制、十六进制的转换有比较深入的了解，了解数据在内存中的存储结构，并且会使用 VC.net 编译简单的控制台程序。 OK ，下面我们开始。

大家都知道任何数据在内存中都是以二进制（ 1 或着 0 ）顺序存储的，每一个 1 或着 0 被称为 1 位，而在 x86CPU上一个字节是 8 位。比如一个 16 位（ 2 字节）的 short int 型变量的值是 1156 ，那么它的二进制表达就是：00000100 10000100 。由于 Intel CPU 的架构是 Little Endian （请参数机算机原理相关知识），所以它是按字节倒序存储的，那么就因该是这样： 10000100 00000100 ，这就是定点数 1156 在内存中的结构。

那么浮点数是如何存储的呢？目前已知的所有的 C/C++ 编译器都是按照 IEEE （国际电子电器工程师协会）制定的IEEE 浮点数表示法来进行运算的。这种结构是一种科学表示法，用符号（正或负）、指数和尾数来表示，底数被确定为 2 ，也就是说是把一个浮点数表示为尾数乘以 2 的指数次方再加上符号。下面来看一下具体的 float 的规格：

float
共计 32 位，折合 4 字节 
由最高到最低位分别是第 31 、 30 、 29 、……、 0 位 
31 位是符号位， 1 表示该数为负， 0 反之。 
30-23 位，一共 8 位是指数位。 
22-0 位，一共 23 位是尾数位。 
每 8 位分为一组，分成 4 组，分别是 A 组、 B 组、 C 组、 D 组。 
每一组是一个字节，在内存中逆序存储，即： DCBA

我们先不考虑逆序存储的问题，因为那样会把读者彻底搞晕，所以我先按照顺序的来讲，最后再把他们翻过来就行了。

现在让我们按照 IEEE 浮点数表示法，一步步的将 float 型浮点数 12345.0f 转换为十六进制代码。在处理这种不带小数的浮点数时，直接将整数部转化为二进制表示： 1 11100010 01000000 也可以这样表示：11110001001000000.0 然后将小数点向左移，一直移到离最高位只有 1 位，就是最高位的 1 ：1.11100010010000000 一共移动了 16 位，在布耳运算中小数点每向左移一位就等于在以 2 为底的科学计算法表示中指数 +1 ，所以原数就等于这样： 1.11100010010000000 * ( 2 ^ 16 ) 好了，现在我们要的尾数和指数都出来了。显而易见，最高位永远是 1 ，因为你不可能把买了 16 个鸡蛋说成是买了 0016 个鸡蛋吧？（呵呵，可别拿你买的臭鸡蛋甩我 ~ ），所以这个 1 我们还有必要保留他吗？（众：没有！）好的，我们删掉他。这样尾数的二进制就变成了： 11100010010000000 最后在尾数的后面补 0 ，一直到补够 23 位： 11100010010000000000000 （MD ，这些个 0 差点没把我数的背过气去 ~ ）

再回来看指数，一共 8 位，可以表示范围是 0 - 255 的无符号整数，也可以表示 -128 - 127 的有符号整数。但因为指数是可以为负的，所以为了统一把十进制的整数化为二进制时，都先加上 127 ，在这里，我们的 16 加上 127 后就变成了 143 ，二进制表示为： 10001111
12345.0f 这个数是正的，所以符号位是 0 ，那么我们按照前面讲的格式把它拼起来： 
0 10001111 11100010010000000000000
01000111 11110001 00100000 00000000
再转化为 16 进制为： 47 F1 20 00 ，最后把它翻过来，就成了： 00 20 F1 47 。 
现在你自己把 54321.0f 转为二进制表示，自己动手练一下！

有了上面的基础后，下面我再举一个带小数的例子来看一下为什么会出现精度问题。 
按照 IEEE 浮点数表示法，将 float 型浮点数 123.456f 转换为十六进制代码。对于这种带小数的就需要把整数部和小数部分开处理。整数部直接化二进制： 100100011 。小数部的处理比较麻烦一些，也不太好讲，可能反着讲效果好一点，比如有一个十进制纯小数 0.57826 ，那么 5 是十分位，位阶是 1/10 ； 7 是百分位，位阶是 1/100 ； 8是千分位，位阶是 1/1000 ……，这些位阶分母的关系是 10^1 、 10^2 、 10^3 ……，现假设每一位的序列是{S1 、 S2 、 S3 、……、 Sn} ，在这里就是 5 、 7 、 8 、 2 、 6 ，而这个纯小数就可以这样表示： n = S1 * ( 1 / ( 10 ^ 1 ) ) + S2 * ( 1 / ( 10 ^ 2 ) ) + S3 * ( 1 / ( 10 ^ 3 ) ) + …… + Sn * ( 1 / ( 10 ^ n ) ) 。把这个公式推广到 b进制纯小数中就是这样： 
n = S1 * ( 1 / ( b ^ 1 ) ) + S2 * ( 1 / ( b ^ 2 ) ) + S3 * ( 1 / ( b ^ 3 ) ) + …… + Sn * ( 1 / ( b ^ n ) )

天哪，可恶的数学，我怎么快成了数学老师了！没办法，为了广大编程爱好者的切身利益，喝口水继续！现在一个二进制纯小数比如 0.100101011 就应该比较好理解了，这个数的位阶序列就因该是 1/(2^1) 、 1/(2^2) 、 1/(2^3)、 1/(2^4) ，即 0.5 、 0.25 、 0.125 、 0.0625 ……。乘以 S 序列中的 1 或着 0 算出每一项再相加就可以得出原数了。现在你的基础知识因该足够了，再回过头来看 0.45 这个十进制纯小数，化为该如何表示呢？现在你动手算一下，最好不要先看到答案，这样对你理解有好处。

 

 

 

 

 

 

我想你已经迫不及待的想要看答案了，因为你发现这跟本算不出来！来看一下步骤： 1 / 2 ^1 位（为了方便，下面仅用 2 的指数来表示位）， 0.456 小于位阶值 0.5 故为 0 ； 2 位， 0.456 大于位阶值 0.25 ，该位为 1 ，并将0.45 减去 0.25 得 0.206 进下一位； 3 位， 0.206 大于位阶值 0.125 ，该位为 1 ，并将 0.206 减去 0.125 得0.081 进下一位； 4 位， 0.081 大于 0.0625 ，为 1 ，并将 0.081 减去 0.0625 得 0.0185 进下一位； 5 位 0.0185小于 0.03125 ，为 0 ……问题出来了，即使超过尾数的最大长度 23 位也除不尽！这就是著名的浮点数精度问题了。不过我在这里不是要给大家讲《数值计算》，用各种方法来提高计算精度，因为那太庞杂了，恐怕我讲上一年也理不清个头绪啊。我在这里就仅把浮点数表示法讲清楚便达到目的了。

OK ，我们继续。嗯，刚说哪了？哦对对，那个数还没转完呢，反正最后一直求也求不尽，加上前面的整数部算够24 位就行了： 1111011.01110100101111001 。某 BC 问：“不是 23 位吗？”我：“倒，不是说过了要把第一个1 去掉吗？当然要加一位喽！”现在开始向左移小数点，大家和我一起移，众：“ 1 、 2 、 3 ……”好了，一共移了 6 位， 6 加上 127 得 133 （怎么跟教小学生似的？呵呵 ~ ），二进制表示为： 10000101 ，符号位为……再……不说了，越说越啰嗦，大家自己看吧： 
0  10000101  11101101110100101111001
42  F6  E9  79
79  E9  F6  42

下面再来讲如何将纯小数转化为十六进制。对于纯小数，比如 0.0456 ，我们需要把他规格化，变为 1.xxxx * （ 2 ^ n ）的型式，要求得纯小数 X 对应的 n 可用下面的公式： 
n = int( 1 + log (2)X ); 再用 X / ( 2 ^ n ) 就可以得到规格化后的小数了。

0.0456 我们可以表示为 1.4592 乘以以 2 为底的 -5 次方的幂，即 1.4592 * ( 2 ^ -5 ) 。转化为这样形式后，再按照上面第二个例子里的流程处理： 
1. 01110101100011100010001
去掉第一个 1
01110101100011100010001
-5 + 127 = 122
0  01111010  01110101100011100010001
最后： 
11 C7 3A 3D

另外不得不提到的一点是 0.0f 对应的十六进制是 00 00 00 00 ，记住就可以了。

最后贴一个可以分析并输出浮点数结构的函数源代码，有兴趣的自己看看吧：

// 输入 4 个字节的浮点数内存数据 
void DecodeFloat( BYTE pByte[4] )
{
 printf( " 原始（十进制）： %d  %d  %d  %d/n" , (int)pByte[0],
  (int)pByte[1], (int)pByte[2], (int)pByte[3] );
 printf( " 翻转（十进制）： %d  %d  %d  %d/n" , (int)pByte[3],
  (int)pByte[2], (int)pByte[1], (int)pByte[0] );
 bitset<32> bitAll( *(ULONG*)pByte );
 string strBinary = bitAll.to_string<char, char_traits<char>, allocator<char> >();
 strBinary.insert( 9, "  " );
 strBinary.insert( 1, "  " );
 cout << " 二进制： " << strBinary.c_str() << endl;
 cout << " 符号： " << ( bitAll[31] ? "-" : "+" ) << endl;
 bitset<32> bitTemp;
 bitTemp = bitAll;
 bitTemp <<= 1;
 LONG ulExponent = 0;
 for ( int i = 0; i < 8; i++ )
 {
  ulExponent |= ( bitTemp[ 31 - i ] << ( 7 - i ) );
 }
 ulExponent -= 127;
 cout << " 指数（十进制）： " << ulExponent << endl;
 bitTemp = bitAll;
 bitTemp <<= 9;
 float fMantissa = 1.0f;
 for ( int i = 0; i < 23; i++ )
 {
  bool b = bitTemp[ 31 - i ];
  fMantissa += ( (float)bitTemp[ 31 - i ] / (float)( 2 << i ) );
 }
 cout << " 尾数（十进制）： "  << fMantissa << endl;
 float fPow;
 if ( ulExponent >= 0 )
 {
  fPow = (float)( 2 << ( ulExponent - 1 ) );
 }
 else
 {
  fPow = 1.0f / (float)( 2 << ( -1 - ulExponent ) );
 }
 cout << " 运算结果： " << fMantissa * fPow << endl;
}

累死了，我才发现这篇文章虽然短，然而确是最难写的。上帝，我也不是机算机，然而为什么我满眼都只有 1 和 0？看来我也快成了黑客帝国里的那个看通迅员了……希望大家能不辜负我的一翻辛苦，帮忙 up 吧