C语言数据的存储详解

数据的存储

数据类型的基本归类

• 整型：char、short、int、long

所有的整型都分有 signed和 unsigned两种

• 浮点型：float、double
• 构造类型：数组、结构体、枚举、联合
• 指针类型
• 空类型

void表示空类型，通常用于函数的返回类型、函数的参数、指针类型。

任何数据类型变量的地址都可以放进空类型的指针，但此指针不可以被使用，只能作为地址的临时存放

void *p=&a;
p++;//err
*p=10;//err

整型在内存中的存储

整型数据类型的取值范围在文件limits.h中定义

对char类型的单独说明

char类型在内存中存储的是字符所对应的ASCII码值，是整数，所以归为整型

代码中直接定义char a是无法确定是signed还是unsigned，这取决于编译器的实现。但除char类型以外的其他整型，都是默认为signed

原码、反码、补码

c语言中有原码，反码，补码。只要是整数，在内存中储存时存的是二进制的补码，而我们使用的是这个数的原码，例如打印时，就是打印的原码

整数，在c语言可以存放到int类型的变量中，int类型是4个字节，即32个bit位。所以1个整数用二进制表示时，需要写0或1共32个

此外，补码规定若二进制每位全为0，则表示数0

在32位bit位中，最高位是符号位，1表示负数，0表示正数。不管所呈现给你的是原码、补码、还是反码，符号位是不会改变的，看见1就是负数，看见0就是正数

举例：

15

000000000000000000000000000001111 原码

000000000000000000000000000001111 反码

000000000000000000000000000001111 补码

正数的原码、反码、补码相同

-15

100000000000000000000000000001111 原码

111111111111111111111111111110000 反码（原码的符号位不变，其他位按位取反）

111111111111111111111111111110001 补码（反码 +1）

为什么整型要在内存中存储补码？

1. 使用补码可以将符号位和数值域统一处理，同时加法和减法也可以统一处理（CPU只有加法器）

比如 int a=1-1，在CPU中是 1+(-1)

1的原码： 00000000000000000000000000000001

-1的原码：10000000000000000000000000000001

若用原码相加则结果为：

10000000000000000000000000000010 =-2

这一结果违背了算术规则，所以我们使用补码

1的补码与原码相同

-1的补码：111111111111111111111111111111111111

补码相加：1000000000000000000000000000000000这里一共 32个0配上最前面的 1，共33个bit位，放入int a发生截断，所以存储进 a的为32个 0，即数 0

2. 补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路

大/小端字节序的存储模式

一个数值超过了一个字节，要将其存储到内存中就会出现顺序问题

因为内存单位为字节，我们以字节为单位去讨论他们的存储顺序，所以在一个单位字节内的数值顺序是不变的

大端字节序存储

大端（存储）模式，是指数据的低位字节的内容保存在内存的高地址中，而数据的高位字节的内容保存在内存的低地址中

小端字节序存储

小端（存储）模式，是指数据的低位字节的内容保存在内存的低地址中，而数据的高位字节的内容保存在内存的高地址中


分析上图，在内存窗口下，从左向右地址是增高的

同时1列表示1个字节，而在单位字节内的顺序是不变的

也可知，我们日常用的电脑都是小端存储

例题理解

unsigned int a= 0x1234; unsigned char b=*(unsigned char *)&a;

问：在32位大端模式处理器上变量b等于（ ）

答：0x00

解释：首先0x1234作为int放在内存中为0x00001234，由于大端存储，所以高字节的内容存储在低地址上所以在内存中的从低地址到高地址存储内容顺序为00001234，而b为char，一次只拿一个字节的内容，所以将第一对00拿走了

经典题目

unsigned、截断、整型提升

int main()
{
	char a = -1;
	signed char b = -1;
	unsigned char c = -1;
	printf("a=%d,b=%d,c=%d", a, b, c);
	return 0;
}
//题目分析
//对于char a =-1，首先我们要获得-1的补码，对于整型数据的操作都是对其补码的操作
//-1的原码：10000000000000000000000000000001
//-1的反码：11111111111111111111111111111110
//-1的补码：11111111111111111111111111111111
//再将-1的补码放入char类型中发生截断得到11111111
//由于a和b打印的结果都为-1说明a也是signed
//a的打印是以%d-打印有符号的整型
//所以对a再进行整型提升
//对于有符号的整型提升就补符号位
//提升得11111111111111111111111111111111
//再进过反码，得到原码
//10000000000000000000000000000001-对应值为-1，所以a打印的-1，b的打印与之同样

//再看unsigned char c = -1
//与a一样，截断得11111111
//再进行整型提升，对于无符号的整型提升是直接补0
//提升的00000000000000000000000011111111
//提升过后，由于打印%d，所以将其看作是有符号的整型，原反补相同，所以对应值为255

int main()
{
	char a = -128;
	printf("%u\n", a);
	return 0;
}
//题目分析
//-128的原码：1000000000000000000000000000010000000
//-128的反码：1111111111111111111111111111101111111
//-128的补码：1111111111111111111111111111110000000
//放入char a中发生截断a-10000000
//这时打印的是%u-打印无符号的整型，先不管有没有符号，要打印整型，说明这里需要整型提升
//而整型提升看的是a原来的数据类型是有符号还是无符号，和它打印方式无关
//提升得：1111111111111111111111111111110000000
//而%u要打印无符号的整型，说明这里的原反补是一样的，所以就直接打印上一行的二进制数对应的值-4294967168

//我们对上题进行小改造
int main()
{
	char a = 128;
	printf("%d\n", a);
	return 0;
}
//题目分析
//128的原码：0000000000000000000000000000010000000，补码也是这个
//再截断a-10000000
//再整型提升1111111111111111111111111111110000000
//而%d打印的是有符号的整型，所以我们还要将上面的补码变成原码
//反码-1111111111111111111111111111101111111
//原码-1000000000000000000000000000010000000 得-128
//这也验证了signed char的取值范围为-128~127

取值范围问题

int main()
{
    char a[1000];
    int i;
    for(i=0; i<1000; i++)
   {
        a[i] = -1-i;
   }
    printf("%d",strlen(a));
    return 0; }

首先要知道，strlen只会遇到’\0’即ASCII码值为0的值才停下；还有，char的取值范围为-128~127

接着分析题目：a[i]=-1-i,当i=128时，a[128]=-129超出范围，发生截断，所以a[128]=127,然后慢慢再减到a[i]=0，此时strlen遇到ASCII码值为0的值而停止，此时i=128+127=255

unsigned引起的取值范围改变问题

unsigned int i;
for(i = 9; i >= 0; i--) {
    printf("%u\n",i);
}

这里由于有unsigned的限制使得i的取值范围变成大于等于0，所以for循环的判断永远成立，所以程序会进入死循环，不停的打印。

当然，这里打印的i先是从9~0，然后从0跳到int类型的最大值，然后慢慢递减至0，这样不断的循环

unsigned char i = 0;
int main()
{
    for(i = 0;i<=255;i++)
   {
        printf("hello world\n");
   }
    return 0; }

这里也是范围问题，unsigned char的取值范围为0~255，显然for循环的判断条件永远成立，所以陷入死循环

数据类型的取值范围

%u-打印的是无符号的整型，认为内存中存放的补码对应的是一个无符号数

%d-打印的是有符号整型，……有符号数

char类型的取值范围

由于char只有八个bit位，所以其横跨的最大范围为2⁸


由这幅图也可知char a=128用%d打印出来的值为-128

所以signed char的范围为-128~127

所以unsigned char的范围为0~255

short类型的取值范围

short为16个bit位，横跨最大范围为2¹⁶

signed short -32768~32767

unsigned short -0~65535

浮点型在内存中的存储

浮点数据类型的取值范围在文件float.h中定义

浮点数的二进制表示

根据国际标准IEEE（电气和电子工程协会） 754，任意一个二进制浮点数V可以表示成下面的形式：

(-1)^S * M * 2^E

• (-1)^S表示符号位，当S=0，V为正数；当S=1，V为负数。
• M表示有效数字，大于等于1，小于2。
• 2^E表示指数位。

举例：十进制的5.5写成二进制为101.1

十分位的权重是 2^-1=0.5,百分位的权重是2^-2=0.25，……

我们再写成二进制的科学计数法为1.011×2²,那么写成标准形式就是V=(-1)⁰ * 1.011 * 2²，即S=0,M=1.011,E=2

浮点数存入内存

IEEE 754规定：

对于32位的浮点数，最高的1位是符号位S，接着的8位是指数E，剩下的23位为有效数字M

对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M。

此外，对于有效数字M和指数E，还有一些特别规定

• 先对M

前面说过，1≤M<2 ，也就是说，M可以写成 1.xxxxxx 的形式，其中xxxxxx表示小数部分。

IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的 xxxxxx部分。

比如保存1.01的时 候，只保存01，等到读取的时候，再把第一位的1加上去。

这样做的目的，是节省1位有效数字。以32位 浮点数为例，留给M只有23位， 将第一位的1舍去以后，等于可以保存24位有效数字。

• 再对E

首先，E为一个无符号整数（unsigned int）

这意味着，如果E为8位，它的取值范围为0-255；如果E为11位，它的取值范围为0-2047。但是，我们知道，科学计数法中的E是可以出现负数的

所以为了防止E中出现负数，所以IEEE 754规定，存入内存时E的真实值必须再加上一个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。

比如，2^10的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即 10001001。

我们以一个例子来加深理解：

float a=5.5

先换成二进制5.5=101.1=1.011 * 2²

这里，S=0,M=1.011,E=2,再将这些存入内存

这里E=127+2=129换成二进制为10000001

M将小数点后的存入，空余的地方补0

浮点数从内存取出

这里分三种情况，其分情况的原因在于E

1. E不全为0或不全为1（这是正常情况）

这时怎么存进来的，就怎么拿出去

即指数E的计算值减去127（或1023），得到真实值，再将

有效数字M前加上第一位的1

2. E为全0

这时，浮点数的指数E等于1-127（或者1-1023）即为真实值。

有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。

这样做是为了表示±0，以及接近于 0的很小的数字

3. E为全1

这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）

经典例题

int main()
{
 int n = 9;
 float *pFloat = (float *)&n;
 printf("n的值为：%d\n",n);
 printf("*pFloat的值为：%f\n",*pFloat);
 *pFloat = 9.0;
 printf("num的值为：%d\n",n);
 printf("*pFloat的值为：%f\n",*pFloat);
 return 0; }

打印结果：

9

0.000000

1091567616

9.0

其实这里有争议的是第二个和第三个打印的结果

这里出现问题的原因在于：整型和浮点型的存储方式不一样

对于第二个打印

是将 以整型规则存储的数据 以浮点型的方式取出

整数9在内存中的存储：

0000 0000 0000 0000 0000 0000 0000 1001

现在以浮点数的规则取出，由于E为全0，所以，浮点数V就写成：

V=(-1)⁰ × 0.00000000000000000001001×2^-126=1.001×2^-146

显然，V是一个很小的接近于0的正数，所以用十进制小数表示就是0.000000

对于第三个打印

浮点数9.0在内存中的存储：

0 10000010 001 0000 0000 0000 0000 0000

现在以整型的方式取出，则这个32位的二进制数，还原成十进制，正是 1091567616

个和第三个打印的结果

这里出现问题的原因在于：整型和浮点型的存储方式不一样

对于第二个打印

是将 以整型规则存储的数据 以浮点型的方式取出

整数9在内存中的存储：

0000 0000 0000 0000 0000 0000 0000 1001

现在以浮点数的规则取出，由于E为全0，所以，浮点数V就写成：

V=(-1)⁰ × 0.00000000000000000001001×2^-126=1.001×2^-146

显然，V是一个很小的接近于0的正数，所以用十进制小数表示就是0.000000

对于第三个打印

浮点数9.0在内存中的存储：

0 10000010 001 0000 0000 0000 0000 0000

现在以整型的方式取出，则这个32位的二进制数，还原成十进制，正是 1091567616