探讨有符号数与无符号数数据上溢出和下溢出问题
<一>下面为有符号数的溢出：
#include<void.h>
Void main()
{
Int i= 2147483647;
Printf(“%d,%d”,i.i+1);
}
输出结果为：2147483647，-2147483648
这是因为加减运算过后，它们的值超出了它们对应的那种整数类型的表示范围，我们把这种现象称为溢出。
注意：看清楚数字总是在循环的变化。如从最大2147483647，再加一后就变成了最小-2147483648。即循环的顺序是：
0— 2147483647— -2147483648— 0。
规律：
SHRT_MAX+1 == SHRT_MIN
SHRT_MIN-1 == SHRT_MAX
例如：
#include <stdio.h>
int main(void)
{
short int a=32767,b=32767,c;
a=a+b; //下面三行代码是实现两数交换的功能
b=a-b;
a=a-b;
c=sizeof(short int);
printf("a=%d,b=%d\n",a,b);
printf("sizeof=%d",c);
return 0;
}
结果：a=32767,b=32767
对学习编程者的忠告：
眼过千遍不如手过一遍！
书看千行不如手敲一行！
手敲千行不如单步一行！
单步源代码千行不如单步对应汇编一行！
考察如下程序段：
int n=1,sum=0;
while(sum<=32767) {sum+=n; n++;}
printf(“n=%d\n”,n-1);
乍看该程序时无错误，但事实上，上列程序中的while循环是一个无限循环，原因在于int型数的表示范围为-32768到+32767，当累加和sum超过32767时，便向高位进位，而对int型数而言，最高位表示符号，故sum超过32767后便得到一个负数，while条件当然满足，从而形成无限循环。此时，最好的解决办法是将sum定义为long int型。
另外google的一道笔试题中也需要意识到溢出的存在
short cal(short x)
{
if(x==0)
return 0;
else
return x+cal(x-1);
}
答案
x==0时，0
x>0时，x+…+1
x<0时，x+(x-1)+…+(-32768)【溢出】+32767+……+1，中途栈溢出
假如是short类型的负数来说，－32768减去1之后，变成32767，就是说对于有符号整数来说：最小的负数－1＝最大的整数，最大的整数＋1＝最小的负数。
假如栈不溢出，那么将递归32768-x+32767次，最后的值按照上面是可以计算出来的
但是栈的空间有限，当栈溢出的时候，错误，强制退出。
在gcc下，测试，假如上述数据类型是char，最后是能计算出值的大小，栈的大小还够用。
<二>下面为无符号数的溢出：
上面提到的是有符号数的溢出，下面是无符号数的溢出
在c语言的程序开发调试中，经常碰到非法操作导致程序强行终止。这种情况的发生多是因为程序指针的指向错误，数据溢出就是其中的一种，下面我将介绍一下常见的几种溢出情况。
1、无符号整数上溢
示例代码：
bool funcB(char *s1,unsigned short int len1,char *s2,unsigned short int len2)
{
if (1 + len1 + len2 > 64)
return false;
char *buf = (char*)malloc(len1+len2+1);
if (buf) {
memcpy(buf,s1;len1);
/*函数解释：void *memcpy(void *to , const void *from, unsigned int count) ：从from指向的内存区向to指向的内存区复制count个字节；如果两内存区重叠，不定义该内存区的定义*/
memcpy(buf+len1,s2,len2);
}
if (buf) free(buf);
return true;
}
这段代码存在整数上溢问题，当len1等于64，len2是0XFFFF，这段代码就会发生溢出。因为在定义为unsigned short char 类型下1＋0xFFFF＝0，这样就绕过了1 + len1 + len2 > 64的条件判断。直接导致后面的代码中错误地分配64字节内存，在内存拷贝时将产生溢出错误。
我分析：无符号整数上溢出的意思就是：无符号整数a已达最大数，+1之后又从小开始计算：1＋0xFFFF＝0；不同于有符号数的是，1＋0xFFFF＝—0xFFFF（最小数SHRT_MAX+1 == SHRT_MIN ）；
2、无符号整数下溢
示例代码：
bool funcA(unsigned int cbSize)
{
if (cbSize < 1024)
{
char *buf = new char[cbSize-1];
memset(buf,0,cbSize-1);
/*
函数解释：void memset(void *buf, int ch, unsigned int count): 把ch的低字节复制到buf指向的内存区的前count个字节处，常用于把某个内存区域初始化已知值。
*/
delete buf;
return true;
}
else
return false;
}
这是一个整数下溢的例子。当函数调用时，如果参数cbSize赋值为0，由于参数cbSize被定义为unsigned int 型，则（cbSize－1）＝ (0－1) = 0XFFFFFFFF,分配如此大的内存，后果可想而知！
我分析：无符号整数下溢就是：无符号整数a为最小值0，再-1后变成最大值，例如：(0－1) = 0XFFFFFFFF；同与有符号整数的是，SHRT_MIN-1 == SHRT_MAX。
----------------------------------
#include <stdio.h>
short int fac( short int x)
{
static short int y=1;
y*=x;
return y;
}
int main(void)
{
int s=0;
short i;
for(i=1;i<=8;i++)
s+=fac(i);
printf("S=%d\n",s);
return 1;
}
运行结果：S=-19303
运行SETP：
Setp1:i=1 y=1 S=0+1=1
Setp2:i=2 y=2 S=1+2=3
Setp3:i=3 y=6 S=3+6=9
Setp4:i=4 y=24 S=9+24=33
Setp5:i=5 y=120 S=33+120=153
Setp6:i=6 y=720 S=153+720=873
Setp7:i=7 y=5040 S=873+5040=5913
Setp8:i=8 y=40320溢出
16位内存空间存储情况：1001,1101,1000,0000(即40320的二进制表示)
反求补码：SETP1(减1)得到：1001,1101,0111,1111
SETP2(按位取反)得到：0110,0010,1000,0000(即25216的二进制表示)
故：y=-25216 S=5913-25216=-19303
Setp9:i=9,for循环结束,执行下一句输出：S=-19303
(40320 1001 1101 1000 0000 反码：1110 0010 0111 1111 补码：1110 0010 1000 0000
0110001010000000为 25216 )
我解释：此代码中的y值40320的意思是，原先在程序中算出来值是40320，记住此时40320就是内存中的补码，同样也是原码，由于正数的原码、反码、补码都相同，然而这个补码表示的意思是：y已不再是40320，由于y为有符号整数，此时，补码40320对应的有符号原码是：-25216，所以才有故：y=-25216 S=5913-25216=-19303。
记住：程序中算出来的数据都是原码。当然，算出来的正数也表示补码！
------------------------------------
#include <stdio.h>
void main()
{
char c1 = 128;//char在此只有八位
unsigned char c2 = 257;
short s1 = 65535;
//short 在此只有16位2^16=65536 2^15=32768
65535=1111 1111 1111 1111B（已为补码） ;由于有符号，就变成了
- 111 1111 1111 1111（已为补码）= - 32767，则其表示的原码为 -1. 因为 - 32767 + （-1）= - 32768.
unsigned int s2 = 65537;
printf("%d,%d,%d,%d",c1,c2,s1,s2);
}
unsigned char c2 = 257这一个
在内存中8位是表示不完的
所以需要9位的二进制才能表示它的值
但一个unsigned char只能存8位的值,所以这里就需要截断
char c1 = 128,char这是一个有符号位的类型
所以在计算它的值的时候,需要用补码方式计算
128在内存中是:1000 0000 (最高一位是符号位)
补码计算,按位取反,再加1得:1000 0000=128
因其符号位是1,所以是负数:-128
输出结果：-128,1,-1,65537
