C语言程序设计笔记---015
- C语言数据的存储
-
- 1、数据类型的意义
- 2、大小端的介绍
-
- 2.1、大小端的例程1
- [2.2、大小端的例程2 --- 判断当前编译器环境属于大端或小端](#2.2、大小端的例程2 --- 判断当前编译器环境属于大端或小端)
- 3、综合练习题探究数据的存储
- 4、浮点数在内存中的存储
- 4.1、浮点数存储规则
-
- [4.1.1、IEEE(电气电子工程师协会) 拟定的754标准](#4.1.1、IEEE(电气电子工程师协会) 拟定的754标准)
- 4.1.2、另外IEE（电气电子工程师协会）754对有效数字M和指数E,还有一些特定的规定
- 4.2、指数E的规定
- 5、经典例子详解
- 6、结语
C语言数据的存储
前言 ：
常见数据类型回顾
char
short
int
long
long long
float
double
那么有没有字符串类型呢？ ---- 没有
字符在内存中存储的是字符的ASCLL码值，所以字符类型归于整型家族
/知识点汇总/
1、数据类型的意义
使用对应类型内存空间的大小（大小决定了适用范围）
unsigned ----- 无符号位
signed ----- 有符号位
值得注意的是。char --- 默认为unsigned 还是 signed 由编译器决定
计算机能够处理的是二进制数据
整型和浮点型数据在内存中也是以二进制的形式进行存储的
整型的二进制表示形式有三种：原码、补码、反码
正整数：原码、反码、补码相同
负整数：原码、反码、补码需要计算；补码等于原码取反加1
最后不管是正整数还是负整数，在内存中的存储都是补码的二进制序列
1.1、unsigned与signed数据类型例程1
javascript
#include <stdio.h>
int main()
{
int a = -10;//4个字节 --- 32bit位
//1000 0000 0000 0000 0000 0000 0000 1010 ----- -10原码
//1111 1111 1111 1111 1111 1111 1111 0101 ----- -10反码
//1111 1111 1111 1111 1111 1111 1111 0110 ----- -10补码
//最高位是符号位（1负，0正）
unsigned int b = -10;
//1111 1111 1111 1111 1111 1111 1111 0110
//此时的b,被unsigned int 修饰此时的最高位就不作为符号位了
return 0;
}小结 ：
对于整形 ：数据存放内存中其实放的是补码
为什么呢？
因为，在计算机系统中，数值一律用补码形式来表示和存储 。原因在于，使用补码，可以将符号位与数据位统一处理。
同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的电路
1.2、补码与原码相互转换例程2
c
#include <stdio.h>
int main()
{
//1-1
//1+(-1)
//0000 0000 0000 0000 0000 0000 0000 0001 --- 1原码
//1000 0000 0000 0000 0000 0000 0000 0001 --- -1原码
//当用原码计算时：
//1000 0000 0000 0000 0000 0000 0000 0010 --- 原码1+（-1），发现达不到想要的结果
//所以再来常识补码相加
//0000 0000 0000 0000 0000 0000 0000 0001 --- 1原码、反码、、补码相等
//1000 0000 0000 0000 0000 0000 0000 0001 --- -1原码
//1111 1111 1111 1111 1111 1111 1111 1110 --- -1反码
//1111 1111 1111 1111 1111 1111 1111 1111 --- -1补码
//补码相加：
//0000 0000 0000 0000 0000 0000 0000 0001 --- 1补码
//1111 1111 1111 1111 1111 1111 1111 1111 --- -1补码
//1 0000 0000 0000 0000 0000 0000 0000 0000 --- 保留后面32位bit --- 0
return 0;
}2、大小端的介绍
大端 --- 大端字节序存储
把一个数据的低位字节处的数据存放在内存的高位地址处 ，把一个数据的高位字节处的数据存放在内存的低位地址处。
小端 --- 小端字节序存储
把一个数据的低位字节处的数据存放在内存的低位地址处 ，把一个数据的高位字节处的数据存放在内存的高位地址处。
2.1、大小端的例程1
c
#include <stdio.h>
int main()
{
int a = 0x11223344;//大小端的不同，存放的顺序就不同
//11 22 33 44 --- 大端存储
//44 33 22 11 --- 小端存储
printf("%p\n",&a);//当前VS2019属于小端存储
return 0;
}2.2、大小端的例程2 --- 判断当前编译器环境属于大端或小端
c
#include <stdio.h>
int check_sys()
{
int a = 1;//只需判断当前属于小端还是大端，所以赋值变量a=1,判断内存中的01的位置即可
//char* p = (char*)&a;//判断只需要一个字节，第一个字节即可
if (*p == 1)
{
return 1;
}
else
return 0;
//return *p;
return *(char*)&a;
}
int main()
{
if (1 == check_sys())
{
printf("小端\n");
}
else
{
printf("大端\n");
}
return 0;
}3、综合练习题探究数据的存储
3.1、练习题1
c
#include <stdio.h>
int main()
{
char a = -1;
//1000 0000 0000 0000 0000 0000 0000 0001 --- -1原码
//1111 1111 1111 1111 1111 1111 1111 1110
//1111 1111 1111 1111 1111 1111 1111 1111 ---- -1补码
//1111 1111 ---- char -1
//因为要以%d格式打印，需要整型提升且以原码打印
//整型提升（以符号位提升）
//1111 1111 1111 1111 1111 1111 1111 1111 --- 整型提升，此时任然为补码
//1000 0000 0000 0000 0000 0000 0000 0000
//1000 0000 0000 0000 0000 0000 0000 0001 --- 原码 == 补码取反加1
//以%d打印 --- -1
signed char b = -1;
//1111 1111 1111 1111 1111 1111 1111 1111 ---- -1补码
//1111 1111 ---- char -1补码
//整型提升（以符号位提升）
//1111 1111 1111 1111 1111 1111 1111 1111 --- 整型提升，此时任然为补码
//1000 0000 0000 0000 0000 0000 0000 0000
//1000 0000 0000 0000 0000 0000 0000 0001 --- 原码 == 补码取反加1
//以%d打印 --- -1
unsigned char c = -1;
//1111 1111 1111 1111 1111 1111 1111 1111 ---- -1补码
//1111 1111 ---- char -1补码 ---- %d --->255
//整型提升（无符号位提升补0）
//0000 0000 0000 0000 0000 0000 1111 1111 --- 整型提升，此时任然为补码
//无符号判定为正整数，原码 = 反码 = 补码
//以%d打印 --- 255
printf("a = %d,b = %d,c = %d",a,b,c);
//整形数据以补码存储
//%d 是以10进制得形式打印有符号的整型数据，以原码打印
return 0;
}3.2、练习题2
c
#include <stdio.h>
int main()
{
char a = -128;
//1000 0000 0000 0000 0000 0000 1000 0000 --- -128
//1111 1111 1111 1111 1111 1111 0111 1111
//1111 1111 1111 1111 1111 1111 1000 0000 --- -128补码
//数据截断：
//1000 0000 --- char -128补码
//整型提升：
//1111 1111 1111 1111 1111 1111 1000 0000 -128补码
//以%u打印，无符号数，所以：
//1111 1111 1111 1111 1111 1111 1000 0000 ----4294967168 原码 = 补码 = 反码
printf("%u\n",a);//4294967168
return 0;
}3.3、练习题3
javascript
#include <stdio.h>
int main()
{
char a = 128;
//0000 0000 0000 0000 0000 0000 1000 0000 --- 128 原码
//1111 1111 1111 1111 1111 1111 0111 1111 ---- 反码
//1111 1111 1111 1111 1111 1111 1000 0000 --- -128补码
//数据截断：
//1000 0000 --- char -128补码
//整型提升：
//1111 1111 1111 1111 1111 1111 1000 0000 补码
//以%u打印，无符号数，所以：
//1111 1111 1111 1111 1111 1111 1000 0000 ----4294967168 原码 = 补码 = 反码
printf("%u\n",a);//4294967168
return 0;
}小结 ：
char类型数据范围：-128~127
char -- 假设是有符号的char --- signed char
范围就是：-128~127 单位字节，1个字节 = 8个bit
//0000 0000 ---- 0
//0000 0001 ---- 1
//0000 0010 ---- 2
//... ...
//0111 1111 ---- 127
//1000 0000 ---- -128
//10000001 ---- -127
//1000 0010 ---- -126
//... ...
//1111 1111 ---- -1
如图所示 ：
注意 ：
首位依然代表符号位
内存中存的二进制序列
内存中存储的补码
char -- 假设是无符号的char --- usigned char
0~255
同理：都会数据截断，将保存正确的字节
3.4、练习题4
c
#include <stdio.h>
int main()
{
int i = -20;
//1000 0000 0000 0000 0000 0000 0001 0100 ---- -20原码
//1111 1111 1111 1111 1111 1111 1110 1011 ---- -20反码
//1111 1111 1111 1111 1111 1111 1110 1100 ---- -20补码（因为整形数据以补码二进制序列保存）
unsigned int j = 10;
//0000 0000 0000 0000 0000 0000 0000 1010 ---- 10原码、反码、补码相等
printf("%d\n",i+j);//-10
//1111 1111 1111 1111 1111 1111 1110 1100 ---- -20补码
//0000 0000 0000 0000 0000 0000 0000 1010 ---- 10原码、反码、补码相等
//1111 1111 1111 1111 1111 1111 1111 0110 ---- i+j 补码
//以%d,打印一个有符号的整数：
//1000 0000 0000 0000 0000 0000 0000 1001 --- 补码取反
//1000 0000 0000 0000 0000 0000 0000 1010 --- -10 补码取反+1,以原码打印
return 0;
}3.5、练习题5
c
#include <stdio.h>
int main()
{
unsigned int i = 0;//unsigned int范围0~255恒大于0与i >= 0，恒成立
for (i = 9; i >= 0; i--)
{
printf("%u\n",i);//死循环
}
return 0;
}3.6、练习题6
c
#include <stdio.h>
#include <string.h>
int main()
{
char a[1000];
int i = 0;
for (i = 0; i < 1000; i++)
{
a[i] = -1 - i;
}
printf("%d",strlen(a));//统计\0之前的个数
//-1 -2 -3 -4 .... -128 127 126 125 ... 5 4 3 2 1 0结束 ---- 255个
//因为char类型范围是：-128 ~ 127，所以其他数都会被数据截断以这个范围的数保存
return 0;
}3.7、练习题7
c
#include <stdio.h>
unsigned char i = 0;//unsigned char范围0~255与i <= 255恒成立
int main()
{
for (i = 0; i <= 255; i++)
{
printf("666\n");//死循环
}
return 0;
}综上所述 ：
当扩展到其他的整型数据类型同理可得：
short --- 2个字节 --- 16bit
signed short范围：-32678~32767
unsigned short范围：0~65535
int --- 4个字节 --- 32bit
signed int范围：-2147483648~2147483647
unsigned int范围：0~4294967295
...
补充 ：为什么char 属于整型呢？
字符在内存中存储的是字符的ASCLL码值，所以字符类型归于整型家族
4、浮点数在内存中的存储
常见的浮点数类型：
float
double
long double
说明：由于浮点数的存储较为复杂，先用一个典型的例子作为引入探究。
c
#include <stdio.h>
int main()
{
int n = 9;
float* pFloat = (float*)&n;
//以整型的形式存储，以浮点数的取出：
printf("n的值为：%d\n",n);//9
printf("*pFloat值为：%f\n",*pFloat);//0.000000
//以浮点数型的形式存储，以整型的取出：
*pFloat = 9.0;
printf("num的值为：%d\n",n);//1091567616
printf("* pFloat值为：%f\n", *pFloat);//9.000000
return 0;
}我们通过此代码的输出结果，产生了与预想结果不同的输出；那么为什么会是以这样的数据输出呢？
那么我们就继续探讨一下，为何会有如此的结果呢？
4.1、浮点数存储规则
4.1.1、IEEE(电气电子工程师协会) 拟定的754标准
根据IEEE(电气电子工程师协会) 拟定的754标准 ，任意一个二进制浮点数，以V表示 ，均可表示为一下形式：
标准格式 ： (-1)^S * M * 2^E
(-1)^S 表示符号位 ，当S = 0,V为正数；当S = 1，V为负数
M表示有效数字 ，范围：大于等于1，小于2
2^E表示指数位
浮点数标准格式：V = (-1)^S * M * 2^E
举个例子 ：
5.5(十进制)
5.5（二进制）：101.1 --- 以权重计算，以小数点分割（小数点右边0.5 == 1/(2^1)）
科学表示格式： (-1)^0 * 1.011 * 2^2
S = 0 ;
M = 1.011 ;
E = 2
注意：因为需要满足IEEE 754标准，所以我们将M的小数点，向左移动了两位，使其满足 1<M<2 的标准范围；其次指数位E也就得到了 2
再举个例子 ：同理
9.0（十进制）
9.0（二进制）：1001.0
科学计数法形式：(-1)^0 * 1.001* 2^3
S = 0;
M = 1.001；
E = 3
对于浮点数的数据存储规定 ：
(1)、对于32位的浮点数，最高的1位是符号位S，接着的8位是指数位E，剩下的23位是有效数字位M
即： 1 8 23
(2)、对于64位的浮点数，最高的1位是符号位S，接着的11位是指数位E，剩下的52位是有效数字位M
即： 1 11 52
4.1.2、另外IEE（电气电子工程师协会）754对有效数字M和指数E,还有一些特定的规定
首先，前面知道了M范围：1<M<2 ，也就是说可以写成1.XXXXXXX的形式，其中的XXXXXXX表示小数部分
所以在IEEE 754中规定，在计算机内部保存M时，默认这个数的第一位是1，那么因此可以将该位的1暂时舍去，等读取时再默认自动添加上。
这样的目的就是节省1位有效数字，提升效率，意义在于使得浮点数的精度更高。
4.2、指数E的规定
4.2.1、指数E的存入规定
然后对于指数E的规定就更为复杂一些，看看下面这个例子 ：
0.5（十进制）
0.1（二进制）
科学计数法表示为：(-1)^0 * 1.0* 2^(-1)
S = 0
M = 1.0
E = -1
通过这里发现，与IEEE 754 规定的E为无符号数冲突，此时出现了负数-1
那么如何通过刚才提到的另外的特殊规定解决呢？
紧接着IEE（电气电子工程师协会）科学家提出了，指数E存入的规定 ：
首先，当E为一个无符号整数（unsigned int） 这意味着，如果E为8位(32位环境)，它的取值范围为0-255；如果E为11位(64位环境)，它的取值范围为0~2047。
但是，我们刚刚的例子知道，科学计数法中的E是会出现负数的，
**所以IEEE 754规定，存入内存时E的真实值必须再加上一个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。**这样进行一个特定的运算，才能保留计算精度，保证数据的完整性和真实性。
比如，2 ^ 10的E是10，所以保存成32位浮点数时，必须保存成10 + 127 = 137，即10001001。
c
#include <stdio.h>
int main()
{
float f = 5.5;
//5.5（十进制）
//101.1（二进制）
//(-1)^0*1.011*2^2（科学表达式）
//S = 0; --- 1bit
//M = 1.011 --- 8bit
//E = 2 --- 23bit
//存储二进制为（在学过IEEE 754标准规定后可知）： -- 32位环境
（S）0 （E）2 + 127 --> 1000 0001 （M）011 (根据符号位补0)00000 00000 00000 00000
//即：0 1000 0001 011 0000 0000 0000 0000 0000
//0100 0000 1011 0000 0000 0000 0000 0000
//十六进制：
//0x 40 b0 00 00
printf("%f\n",f);
printf("%p\n",&f);
return 0;
}如图所示 ：
当我们了解的E指数位数据的存入标准，那么我们又是如何取出使用呢？
4.2.2、指数E的取出规定三种情况
指数E从内存中取出规定还可以再分成三种情况 ：
1.E不全为0或不全为1
2.E全为0
3.E全为1
(1).E不全为0或不全为1
这时，浮点数就采用下面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将有效数字M前加上第一位的1。
比如： 0.5（1/2）的二进制形式为0.1，由于规定正数部分必须为1，即将小数点右移1位，则为1.0*2^(-1)，其阶码为-1+127=126，表示为01111110，而尾数1.0去掉整数部分为0，补齐0到23位00000000000000000000000，则其二进制表示形式为:
0 01111110 00000000000000000000000
(2).E全为0
这时，浮点数的指数E等于 1-127（或者1-1023）即为真实值，有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。
这样做是为了表示 ±0，以及接近于0的很小的数字（理解为无穷小）。
(3).E全为1
这时，如果有效数字M全为0，表示 ±无穷大（正负取决于符号位s）
现在学习了以上知识点，再回顾上面那道题
5、经典例子详解
(1)、以整型的形式存储，以浮点数的取出：
首先，这里先定义了一个整型的正整数变量 n = 9，在上面知识点讲到，正整数的原码。反码、补码相等。
所以，我们代码中以%d格式打印 n的值，不言而喻等于 9，正常输出；
然后我们看到代码中定义了一个浮点型的指针变量 pFloat ，并令n的地址强转后赋值给它，然后我们根据上面提到的IEEE(电气电子工程师协会) 拟定的754标准和规则，知道了浮点数的存储方式。所以，当n的地址强转为浮点型时，立马通过n变量的二进制序列，知道采用标准的科学计数法表示：
0（S） 0000 0000(E) 00000000000000001001(M)
S = 0 ，E = 0 ，M = 0.00000000000000001001
由于E为全0的情况，通过标准规定知道，它的真实存储形式需要使，E = 1 - 127 = -126，且我们舍去的最高位的1不再还原回来。
最后我们将还原为真实的 pFloat 值以科学表示法表示为：
(-1)^0 * 0.00000000000000001001* 2^(-126)
不难看出是一个巨小的数，无限接近于0，无穷小，约等于0
所以当我们以%f的格式打印时，结果自然而然就为：0.000000
(2)、以浮点数型的形式存储，以整型的取出：
接下来，我们继续探究后面的代码，当我们将9.0一个浮点型的数据存入一个float* 变量 pFloat时，通过上面的讲解不难理解，以浮点型存入，以%f格式打印，就正常输出9.000000；
那么重点讲解的是，当以浮点型存入，以%d格式输出时的情况：
首先，我们知道了IEE 754标准，立马反应知道以科学表示格式表示，所以：
二进制转换大家都会就不多赘述，（十进制）9.0转换为二进制得到 1001.0，再以科学计数法表示为：
(-1)^0 * 1.001* 2^3
S = 0，E = 3，M = 1.001
又因为当前编译器环境是32位，所以：执行 1 8 23标准（见上文）
0(S) 1000 0010(E) 001 000000000000000000000(M补0，1暂时舍去)
即：0 1000 0010 001 000000000000000000000
以二进制表示：
0100 0001 0001 0000 0000 0000 0000 0000
以十六进制表示：
0x41 10 00 00
以十进制%d打印表示：
1091567616
如图所示 ：
代码部分：
c
#include <stdio.h>
int main()
{
int n = 9;
//0000 0000 0000 0000 0000 0000 0000 1001 --- 9原码、反码、补码相等
float* pFloat = (float*)&n;
//当编译器识别此时为float类型时，就自动识别为：
//0 0000 0000 00000000000000001001
//S = 0
//E = 0 ---全0的情况,E = （1 -127）= -126 ，且M不再添加舍去的最高位1
//M = 0.00000000000000001001
//科学表示法：
//(-1)^0*0.00000000000000001001*2^(-126) ---- 接近于无穷小得约等于0
//以整型的形式存储，以浮点数的取出：
printf("n的值为：%d\n",n);//9
printf("*pFloat值为：%f\n",*pFloat);//0.000000
//以浮点数型的形式存储，以整型的取出：
*pFloat = 9.0;
//9.0
//1001.0
//(-1)^0*1.001*2^3
//S = 0
//M = 1.001
//E = 3 （3+127）----> 1000 0010
//二进制序列：
//0 1000 0010 001 000000000000000000000
//0100 0001 0001 0000 0000 0000 0000 0000 --- float形式存入，且原码、反码、补码相同
printf("num的值为：%d\n",n);//以%d形式打印，1091567616
printf("* pFloat值为：%f\n", *pFloat);//9.000000
return 0;
}（当前编译器以小端存储方式）验证结果，如图所示：
6、结语
半亩方糖一鉴开，天光云影共徘徊。
问渠哪得清如许?为有源头活水来。--朱熹（观书有感）