一、内功之数据在内存中的存储
本章内容重点： 1.数据类型的不同类型 2.整型在内存中的存储方式 3.大小端字节序存储 4.浮点数在内存中的存储方式
1.不同数据类型的介绍
我们先前已经了解到的基本类型（内置类型）如：
char //字符型，所占存储空间为1字节 int //基本整形，所占存储空间为4字节 unsigned int //无符号整型，所占存储空间为4字节 long (int) //长整型，所占存储空间为4/8字节 unsigned long //无符号长整型，所占存储空间为4/8字节 long long (int) //长长整型，所占存储空间为8字节 short (int) //短整型，所占存储空间为2字节 unsigned short //无符号短整型，所占存储空间为2字节 float //单精度浮点型，所占存储空间为4字节 double //双精度浮点型，所占存储空间为8字节 long double //长双精度浮点型
类型存在的意义：
1.使用不同数据类型为内存开辟不同的空间大小
2.不同数据所能表示的取值范围不同，可以参与的运算也不同
1.1🌜数据类型的分类🌛
- 整型家族👪
char-----unsigned char signed char short----unsigned short signed short int-------unsigned int signed int long-----unsigned long signed long 为什么char也在整型家族呢？因为字符是以ASCII存储在内存中，ASCLII是整数，所以char属于整型合情合理👀（解决某些人的小疑问）。但是这里要注意❗：在我们编程过程中，char具体表示的是signed char还是unsigned char是要根据编译器决定的，常见的编译器认为char 是signed char。
- 浮点数家族👪
float double
- 构造类型（自定义类型）👪
数组类型（因为数组元素个数可以发生改变） 结构体类型struct 枚举类型enum 共用体（联合）类型union
- 指针类型👪
int* pa char* pb float* pc void *pd
- 空类型👪
void表示空类型（无类型） 通常用于函数的返回类型，函数的参数，指针类型。
2.🌜整型在内存中的存储🌛
由于一个变量在内存中存储需要开辟内存的存储单元，而不同的类型所开辟的空间大小有所不同，那么接下深刻理解一下整型 数据在内存中的存储👀
首先，我们要提前具备以下知识点：
有符号整数和无符号整数整数的原码、反码、补码
2.1有符号整型和无符号整型（从二进制来看）
有符号整数和无符号整数的区别在于如何理解整数最高位
- 对于无符号整数：整数的最高位被编译器理解为数据位。
- 对于有符号整数：整数的最高位被编译器理解为符号位。若最高位（符号位）为0则表示正数，若符号位为1则表示负数。
- 可见对于相同字节数的整型数而言：由于有符号整数的数据位数比无符号整数的数据位数少1位，而这1位恰好是最高位，因此有符号整数表示的最大整数的绝对值只有无符号整数的一半
//举个栗子：我们可以查到char(signed char)和unsigned char的取值范围 //char占1个字节 char---> -128~127 unsigned char--->0~255
编辑
在内存中的存储形式如上图
2.2整数的原码、反码和补码
计算机中整数的三种表示方法：原码、反码和补码。三种方法都存在符号位和数据位之分。
由于正数的原码反码补码相同，而负数的原码反码补码不同，规则如下：
原码：将二进制按照正负数直接翻译即可 反码：原码的符号位不变，其他位依次按位取反 补码：在反码的基础上+1得到补码 注意： 1.通过对补码按“符号位不变，其他位依次取反”后“+1”可得到原码。 2.同样，对补码先“-1”后，再“符号位不变，其他位依次取反”可得到原码。
//例如： int a=20; //20是正数，最高位是符号位0，整形占四个字节32个比特位 //正数的原码反码补码：0000 0000 0000 0000 0000 0000 0001 0100 //转换为十六进制：0x 00 00 00 16 int b=-10; //-10是负数，最高位是符号位1 //原码：1000 0000 0000 0000 0000 0000 0000 1010 //反码：1111 1111 1111 1111 1111 1111 1111 0101 //补码：1111 1111 1111 1111 1111 1111 1111 0110 //转换为十六进制：0xff ff ff f6
对于整型而言：在屏幕上显示的是该数的原码，在内存中存储的是该数的补码，这是为什么呢？😧
在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统一处理；同时， 加法和减法也可以统一处理（ CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。
//举个栗子解释一下：当我们计算2-1的时候【相当于2+(-1)】 2 //由于正数的原码、反码、补码相同： 0000 0000 0000 0000 0000 0000 0000 0010 -1 //32位机器上-1的原码：由于是负数，最高位为符号位1 1000 0000 0000 0000 0000 0000 0000 0001 //-1的反码：原码符号位不变，其他位按位依次取反 1111 1111 1111 1111 1111 1111 1111 1110 //-1的补码：反码+1 1111 1111 1111 1111 1111 1111 1111 1111 2-1//相当于2+（-1）：如果不使用补码，用原码计算 0000 0000 0000 0000 0000 0000 0000 0010 1000 0000 0000 0000 0000 0000 0000 0001 // 1000 0000 0000 0000 0000 0000 0000 0011 //得出结果：-3，可见2-1=-3是错误的 //当我们使用-1的补码计算的时候 0000 0000 0000 0000 0000 0000 0000 0010 1111 1111 1111 1111 1111 1111 1111 1111 //得出结果：1 0000 0000 0000 0000 0000 0000 0000 0000 0001 //由于只有32位，最前面的1舍掉得出：0000 0000 0000 0000 0000 0000 0000 0000 0001 //也就是1，2-1=1结果是正确的
通过在计算机内存中负数用补码来表示，就可以将减法运算也转化为加法运算来处理。😁
2.3❗大小端字节序存储❗
在了解大小端存储之前，我们看一下在VS编译器中数据在内存中存储是什么样子的?
在VS编译器中：按住Ctrl+F10进行调试，打开软件上面调试选项，点击窗口下的内存即可打开
编辑
int a=20; //20的原码、反码、补码都相同： //0000 0000 0000 0000 0000 0000 0001 0100 int b=-10; //-10是负数 //原码：1000 0000 0000 0000 0000 0000 0000 1010 //反码:符号位不变，其他位依次按位取反 //反码：1111 1111 1111 1111 1111 1111 1111 0101 //补码：反码+1 //补码：1111 1111 1111 1111 1111 1111 1111 0110 在内存中是以十六进制显示的(二进制和十六进制的转换) //20以十六进制显示：00 00 00 14 //-10以十六进制显示：ff ff ff f6 //在内存中以补码形式存储数据
为什么在内存中存储方式和图片显示不符合呢？接下来正式引入功法！💣
编辑
1.什么是大端小端？
大端字节序存储模式：数据的低位保存在内存的高地址处，数据的高位保存在内存的低地址处。小端字节序存储模式：数据的低位保存在内存的低地址处，数据的高位保存在内存的高地址处。
2.为什么有大端小端存储呢？
为什么会有大小端模式之分呢？这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为8bit。但是在C语言中除了8 bit的char之外，还有16 bit的short型，32 bit的long型（要看具体的编译器），另外，对于位数大于8位的处理器，例如 16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如 何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。例如：一个 16bit 的 short 型 x ，在内存中的地址为 0x0010 ， x 的值为 0x1122 ，那么 0x11 为高字节， 0x22 为低字节。对于大端模式，就将 0x11 放在低地址中，即 0x0010 中， 0x22 放在高地址中，即 0x0011 中。小端模式，刚好相反。我们常用的 X86 结构是小端模式，而 KEIL C51 则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。
3.解释图片中的问题
int a=20; int b=-10; //20以十六进制显示：00 00 00 14 //-10以十六进制显示：ff ff ff f6
编辑
可见在VS的内存存储方式为小端字节序存储
4.面见笔试题
百度2015年系统工程师笔试题：请简述大端字节序和小端字节序的概念，设计一个小程序来判断当前机器的字节序。
//功能：设计一个小程序来判断当前机器的字节序。 //思路：判断大小端存储，假如数据int a=20,在内存中十六进制表示是00 00 00 16， //设计程序判断第一个字节是00还是16，若是00表示是大端，反之为小端 //要点：根据不同类型指针实现对数据内存的访问多大的空间 int main() { int a = 20; int result = *((char*)&a); //char*指针表示对内存访问一个字节的空间 //解引用为对应一个字节的值 if (result) { printf("机器是小端存储"); } else { printf("机器是大端存储"); } return 0; } //函数实现： int check() { int a = 20; return (*(char*)&a); } int main() { int result =check(); //char*指针表示对内存访问一个字节的空间 //解引用为对应一个字节的值 if (result) { printf("机器是小端存储"); } else { printf("机器是大端存储"); } return 0; }
2.4🎓练习题🎓
1.第一题+解析😶
//输出什么？ #include <stdio.h> 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取值范围是：0~255 //char a在内存中的二进制为：（负数） //原码：1000 0000 0000 0000 0000 0000 0000 0001 //反码：1111 1111 1111 1111 1111 1111 1111 1110 //补码：1111 1111 1111 1111 1111 1111 1111 1111 //由于是char类型占一个字节，需要整型提升：取后八位 //1111 1111，整型提升原则：前面与补符号位相同的 //1111 1111 1111 1111 1111 1111 1111 1111为整型提升后的补码 //打印格式为%d有符号整型数据： //原码：补码取反（符号位不变）+1 //1000 0000 0000 0000 0000 0000 0000 0001：-1 //signed char b=-1和char a=-1结果是一样的--->-1 unsigned char c=-1; //参考上面可知且unsigned表示不区分符号位，统一按数值位看，全为正数 //原码：1000 0000 0000 0000 0000 0000 0000 0001 //反码：1111 1111 1111 1111 1111 1111 1111 1110 //补码：1111 1111 1111 1111 1111 1111 1111 1111 //由于是char类型占一个字节，需要整型提升：取后八位 //1111 1111，整型提升原则：由于是无符号，不区分负数，所以前面补0 //0000 0000 0000 0000 0000 0000 1111 1111：2^8-1=255
最终结果：a=-1,b=-1,c=255
🌞补充一张“轮回转生”🌞
编辑
正确理解char的取值范围
2.第二题+解析😶
2. #include <stdio.h> int main() { char a = -128; printf("%u\n",a); return 0; }
char a=-128;//a是负数 //a的原码：1000 0000 0000 0000 0000 0000 1000 0000 //a的反码：1111 1111 1111 1111 1111 1111 0111 1111 //a的补码：1111 1111 1111 1111 1111 1111 1000 0000 //由于是char类型占一个字节，需要整型提升：取后八位 //1000 0000，整型提升原则：补符号位1 //1111 1111 1111 1111 1111 1111 1000 0000为整型提升后的结果 //打印格式为：无符号整型,最前面的符号位看作数据位 //1111 1111 1111 1111 1111 1111 1000 0000=4294967168
最终结果：4294967168
3.第三题+解析😶
3. #include <stdio.h> int main() { char a = 128; printf("%u\n",a); return 0; }
//a是正数，原码反码补码相同 //a的原码：0000 0000 0000 0000 0000 0000 1000 0000 //a的补码：0000 0000 0000 0000 0000 0000 1000 0000 //由于是char类型占一个字节，需要整型提升：取后八位 //1000 0000，整型提升原则：补符号位1 //1111 1111 1111 1111 1111 1111 1000 0000为整型提升后的补码 //打印格式为：无符号整型,最前面的符号位看作数据位 //1111 1111 1111 1111 1111 1111 1000 0000=4,294,967,168
4.第四题+解析😶
int main() { int i = -20; unsigned int j = 10; printf("%d\n", i + j); //按照补码的形式进行运算，最后格式化成为有符号整数 return 0; }
//i为负数：符号位为1 //原码：1000 0000 0000 0000 0000 0000 0001 0100 //反码：1111 1111 1111 1111 1111 1111 1110 1011 //补码：1111 1111 1111 1111 1111 1111 1110 1100 //j为无符号整数 //原码=补码：0000 0000 0000 0000 0000 0000 0000 1010 //i+j //1111 1111 1111 1111 1111 1111 1110 1100 //0000 0000 0000 0000 0000 0000 0000 1010 //补码结果：1111 1111 1111 1111 1111 1111 1111 0110 //原码：补码按位取反+1 //1000 0000 0000 0000 0000 0000 0000 1010=-10
计算结果为：-10
5.第五题+解析😶
unsigned int i; for(i = 9; i >= 0; i--) { printf("%u\n",i); }
由于int i是无符号整型，所以取值不可能小于（<）0. 所以程序中的i>=0判断条件，不论i--恒成立，输出结果会发生死循环
6.第六题+解析😶
int main() { char a[1000];//字符型数组 int i; for(i=0; i<1000; i++) { a[i] = -1-i;//分别对数组的每一个元素赋值 //-1 -2 ...-128 127 126 ...0 1... } printf("%d",strlen(a)); //strlen读取字符串长度，直到\0才停止，\0的ASCII值为0.也就是说strlen统计的是0之前有多少个元素 //从-1到-128到0一共有255个元素 return 0; }
因为char的取值范围在-128~127之间，对数组赋值到char数组中不可能超出这个范围 所以计算结果为：255
7.第七题+解析😶
unsigned char i = 0; int main() { for(i = 0;i<=255;i++) { printf("hello world\n"); } return 0; }
同理，i<=255判断条件不论i++恒为真，程序会不断打印陷入死循环
注意：特别关注题目中以及编程过程中遇到unsigned，可能会发生bug👾
3.🌜浮点型数据在内存中的存储🌛
常见的浮点数有哪些呢？
比如：3.14159261E10：E+数字表示10的数字次方浮点数家族：float double等等浮点数的范围：需要在float.h中查看--->使用evenrything 这个软件搜索limits.h和float.h可以查看在C语言中double和float的取值范围。
3.1抛砖引玉💡
我们先看下面这个例子
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; }
编辑
接下来解释一下输出的结果：
int n = 9; //n的值为整型 float *pFloat = (float *)&n; //取n的地址强制类型转换为浮点型指针类型，将取到的地址放到变量pFloat中，变量pFloat的类型是浮点型指针 printf("n的值为：%d\n",n); //此时以整型打印整型n的值：结果为9 printf("*pFloat的值为：%f\n",*pFloat); //对pFloat浮点型指针进行解引用操作，以浮点型打印整型n的结果：为0.0000000 *pFloat = 9.0; //间接修改n的值为9.0浮点型 printf("num的值为：%d\n",n); //以整型打印浮点数n的值：9.0000000 printf("*pFloat的值为：%f\n",*pFloat); //对pFloat浮点型指针进行解引用操作，以浮点型打印整型n的结果：为9.000000
也就是说：整型数据用整型输出，用浮点型输出结果会发生变化，说明在内存中浮点型数据和整形数据的存储方式不同。接下来详细介绍：
3.2浮点数的存储规则
根据国际标准IEEE（电气和电子工程协会） 754，任意一个二进制浮点数V可以表示成下面的形式： 1. (-1)^S * M * 2^E 2. (-1)^s表示符号位，当s=0，V为正数；当s=1，V为负数。 3. M表示有效数字，大于等于1，小于2。 4. 2^E表示指数位。
//举例说明 float num=5.0 //在内存中十进制转换为二进制存储的方式可以写成： 101.0 //又可以表示成： 1.010*2^2 //对应：(-1)^S * M * 2^E,可以表示为： (-1)^0*1.010*2^2 //计算得出： S=0;M=1.010;E=2
IEEE 754规定：对于32位的浮点数，最高的1位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。
编辑
在32位机器下，内存中的存储格式
对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M
编辑
在64位机器下，内存中的存储格式
对于指数M的特别规定：
IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的 xxxxxx部分。比如保存1.01的时候，只保存01，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省1位有效数字。以32位浮点数为例，留给M只有23位，将第一位的1舍去以后，等于可以保存24位有效数字。
//也就是说，上面的举例中：这样做可以提高保存在内存中的数据的精度 M=0.010
对于指数E的特别规定：
首先，E为一个无符号整数（unsigned int）这意味着，如果E为8位，它的取值范围为0~255；如果E为11位，它的取值范围为0~2047。但是，我们知道，科学计数法中的E是可以出现负数的，所以 IEEE 754规定，存入内存时E的真实值必须再加上一个中间数，对于8位的E，这个中间数 是127；对于11位的E，这个中间 数是1023。比如，2^10的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即10001001。 指数E从内存中取出还可以再分成三种情况： E不全为0或不全为1这时，浮点数就采用下面的规则表示，即 指数E的计算值减去127（或1023），得到真实值，再将 有效数字M前加上第一位的1。（因为之前M存储的是0.xxxxx，需要再把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 E全为0 这时，浮点数的指数E等于1-127（或者1-1023）即为真实值（指数级为负已经相当小了） 有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于 0的很小的数字。 E全为1 如果有效数字M全为0，表示±无穷大（正负取决于符号位s）；
3.3解释抛砖引玉的结果
//在32位平台下 int main() { int n = 9; //n为正数，原码反码补码相同：0000 0000 0000 0000 0000 0000 0000 1001 float *pFloat = (float *)&n; printf("n的值为：%d\n",n); printf("*pFloat的值为：%f\n",*pFloat); //将整数9按照浮点数存储规则进行会出现如下结果： 0 00000000 00000000000000000001001 S=0;E=00000000；M=00000000000000000001001//符合E全为0的情况 //也就是：(-1)^0*0*2^(-118) 打印结果为：0.000000 *pFloat = 9.0; //此时n看作是浮点数 printf("num的值为：%d\n",n); //以整型的方式打印浮点数：需要先将浮点数在内存中取出.我们先看9.0存入内存的方式 //9.0用二进制表示为： 1001.0 //进一步用浮点数表示为： (-1)*0*1.001*2^3 //此时S=0,M=1.001,E=3 //存储在内存时：S=0,M=0.001,E=3+127=130 用二进制表示为：0 10000010 00100000000000000000000 //以整型方式显示：01000001000100000000000000000000 //通过二进制转十进制的方式得出： 1,091,567,616 printf("*pFloat的值为：%f\n",*pFloat); //以浮点数形式打印浮点数9.0，结果为： 9.000000 return 0; }
注意：
- 浮点数举例避免举小数点太复杂的例子，因为得出指数E+127很难用二进制表示，理解即可👌
2.解释了为什么我们在编程时有些数据用float和double 时输入数据相同，输出数据有稍微差异，因为在内存中存储时M占的位数有所不同，也就是说：浮点型数据存入内存和取出内存会有精度缺失的现象。
3.4浮点数的相关术语字典
- 定点数：指的是小数点位置是固定的，小数点位于符号位和第一个数值位之间，它表示的是纯小数。
- 浮点数：实数N可统一表示为：N=S*r^j，其中：S为尾数，规定用纯小数表示；j为阶码（正负均可，但必须为整数）；r是基数，对二进制而言，r=2。例如：10.0111=10100111*2^10
