这是我的第二篇博客，非常感谢大家的支持，以后我会继续更新关于C语言和C++以及嵌入式的内容，如果有问题的话，恳请各位大佬在评论区指正，我会努力把每部分的知识给大家讲懂，下面正文开始。
1. 整数在内存中的存储
整数的二进制表示方法有三种，即原码，补码，反码。
有符号的整数，三种表示方法均有符号位和数值位两部分。符号位都是用0表示正，1表示负，最高一位是符号位，其余都是数值位。
原码：直接将数值按照正负数的形式翻译成⼆进制得到的就是原码。
反码：将原码的符号位不变，其他位依次按位取反就可以得到反码。
补码：反码+1就得到补码。
正整数的原码，补码， 反码都相同，负整数的原码，反码，补码就按照定义来。
对于整形来说，数据在内存中其实放的是补码。为什么呢？
原因是使⽤补码，可以将符号位和数值域统⼀处理；同时，加法和减法也可以统⼀处理（CPU只有加法器）。此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。
2. 大小端字节序和字节序判断
当我们了解了整数在内存中存储后，我们调试看⼀个细节：
#include<stdio.h>
int main()
{
int a = 0x11223344;
return 0;
}
在这里，我是用VS2022来调试的，我们可以看到 0x11223344 这个数字是按照字节为单位，倒着存储的
在这里，我们发现数据的低位字节内容保存在内存的低地址处，⽽数据的⾼位字节内容，保存在内存的⾼地址处。下面我们引出大小端的概念。
2.1 什么是大小端？
其实超过⼀个字节的数据在内存中存储的时候，就有存储顺序的问题，按照不同的存储顺序，我们分为大端字节序存储和小端字节序存储，下⾯是具体的概念：
大端（存储）模式：
是 指数据的低位字节内容保存在内存的⾼地址处，而数据的高位字节内容，保存在内存的低地址处（可以理解为正着放）。
小端（存储）模式：
是 指数据的低位字节内容保存在内存的低地址处，而数据的高位字节内容，保存在内存的⾼地址处。（可以理解为倒着放）
在VS2022中数据存储是以小端模式存储的，就是倒着放。
2.2 为什么有大小端?
为什么会有大小端模式之分呢？
这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着⼀个字节，⼀个字节为8 bit 位，但是在C语言中除了8bit的 char 之外，还有16bit的 short 型，32bit的 long 型（要看 具体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器（处理器）宽度大于⼀个字节，那么必然存在着⼀个如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。
例如：⼀个 16bit 的 short 型 x ，在内存中的地址为0x0010 ,x 的值为 0x1122。那么0x11 为⾼字节, 0x22 为低字节。对于大端模式，就将 0x11放在低地址中，即 0x0010，0x22放在高地址处，即 0x0011 中。小端模式，刚好相反。我们常用的X86 结构是小端模式，而keil C51（51单片机会用到的软件） 则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。
下面来做一些练习来巩固一下大小端的知识。
2.3 练习
2.3.1 练习1
请简述大端字节序和小端字节序的概念，设计⼀个⼩程序来判断当前机器的字节序。(百度笔试题）
关于大小端字节的概念上面已经说过，这里就不再赘述了。下面我们来看如何实现一个程序来判断机器的字节序，我们不能想当然的通过调试来解决，要让结果显示在屏幕上，直接告诉我们是大端还是小端。
方法1：
#include<stdio.h>
int check_sys()
{
int i = 1;
return (*(char *)&i);
}
int main()
{
int ret = check_sys();
if(ret == 1)
{
printf("⼩端\n");
}
else
{
printf("大端\n");
}
return 0;
}
check_sys函数中定义了一个局部变量1，在32位的处理器中其二进制表示方法为 0000 0000 0000 0000 0000 0000 0000 0001 ，16进制中表示方法为 0x 00 00 00 01，&i是把i的地址取出来，类型是int *,然后强转为char *,然后再解引用，就访问到了一个字节（该字节是存储在内存低地址处的），主函数里调用check_sys函数，判断返回值，根据大小端字节的定义就得到结果
进入VS的调试过程就看到如下结果
可以看到01放在最前面（也就是低地址处）符合小端存储的定义，下面是运行结果
方法二很巧妙，用了联合体的方法（这个方法叫我在考场上独立写出来，我估计也写不出来）
int check_sys()
{
union
{
char c;
int i;
}un;
un.i = 1;
return un.c;
}
int main()
{
int ret = check_sys();
if (ret == 1)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
}
这里先简单介绍一下联合体，关于联合体的具体知识，我之后会专门出一篇博客来讲解。
联合体是由⼀个或者多个成员构成，这些成员可以不同的类型。但是编译器只为最大的成员分配足够的内存空间。联合体的特点是所有成员共用同⼀块内存空间。所以联合体也叫：共用体。
联合的大小至少是最大成员的大小。当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。关于最大对齐数，我会在有关结构体那一篇博客讲到。这里我们知道这里un联合体的大小为4个字节。下面是示意图（地址是瞎填的，具体地址取决与编译器）
我们把un.i的值置为1 ，在32位的处理器中用二进制来表示为 0000 0000 0000 0000 0000 0000 0000 0001，用16进制表示为0x 00 00 00 01，最后我们返回的是un.c的值，un.c的地址就是操作系统分配的低地址，取出这个值，判断它的值，根据定义一样能判断出当前机器是大端还是小端。该方法比较巧妙，写出来能给人眼前一亮的感觉。
2.3.2 练习2
下面程序的输出结果是什么
#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;
}
当然在这里先说明一下，我们自己在写程序的时候不要这么写，int用%d来打印，char用%f 打印（或者选择保留几位小数，这里就不再说了）这个只是题目这么考的。
首先我们要知道char 到底是有符号的还是无符号的是取决于编译器的，在VS中，char是有符号的，我们之前说过整数在内存中的是以补码形式存储的。
以四个字节来看，-1补码为1111 1111 1111 1111 1111 1111 1111 1111
-1的原码为1000 0000 0000 0000 0000 0000 0000 0001
存储在a里面的是1111 1111因为char 是一个字节，所以取低8位
a="%d"要整形提升 char(在VS中）最高位为符号位，符号位为1，整形提升后在前面全补1，即
1111 1111 1111 1111 1111 1111 1111 1111（这是补码形式），所以a=%d输出为-1，同理b=%d输出也为-1
signed char 表示范围为-128到127 unsigned char 表示范围为0到255，对于c,虽然-1不在0到255范围内，但仍可存在c里，最后以%d打印
同理c存的是 1111 1111
整形提升后，unsigned char 最高位不是符号位，所以前面全补0，即
0000 0000 0000 0000 0000 0000 1111 1111，以%d打印出来即为255
下面是运行结果
2.3.3 练习3
下面两个程序的运行结果是什么
先看第一个程序
#include <stdio.h>
int main()
{
char a = -128;
printf("%u\n",a);
return 0;
}
上面我们说过在VS中char 会被认为是有符号的数字
以四个字节来看（即32位）
-128的原码 1000 0000 0000 0000 0000 0000 1000 0000
-128的反码 1111 1111 1111 1111 1111 1111 0111 1111
-128的补码 1111 1111 1111 1111 1111 1111 1000 0000
所以在a里面存的是1000 0000
以“%u"的形式打印，认为a中存储的是无符号的数字
a是char类型，要进行整形提升，整形提升后为
1111 1111 1111 1111 1111 1111 1000 0000，由于以%u的形式打印，这个数为无符号的数，即为正数，正数的原码和补码相等，然后再将这个数转为10进制，即为下面的结果
我们再来看一个和这个程序很像的程序
#include <stdio.h>
int main()
{
char a = 128;
printf("%u\n", a);
return 0;
}
可以发现这个程序和上一个程序的差别就是a从-128变到了128
128的原码补码和反码都相等，即为（以4个字节来看）
0000 0000 0000 0000 0000 0000 1000 0000
所以a中存储的是1000 0000
整形提升后为 1111 1111 1111 1111 1111 1111 1000 0000
以“%u"的形式打印，把这个数看成无符号的整数，正数的原码和补码相同，将这个2进制转为10进制即得到下面结果，和上面一个代码运行结果相同
2.3.4 练习4
下面程序的运行结果是什么
#include <stdio.h>
int main()
{
char a[1000];
int i;
for (i = 0; i < 1000; i++)
{
a[i] = -1 - i;
}
printf("%d", strlen(a));
return 0;
}
a数组中的每一个元素是char类型的，在VS中char被当成signed char ，此时char的范围为-128到127，所以我们不能天真的以为a数组中的元素减到-128之后就是-129了，a数组中的元素为
-1 -2 -3 ...-128,这是前面的一些数据，到减到-128后结果是啥呢，我们不妨来画个图，该图如下
我们用补码形式来以此加或减，1的补码为0000 0001，加1之后就变为 0000 0010 ，一直当加到127的时候（0111 1111），再加一就变为1000 0000，由于符号位是1，该数为负数，1000 0000即为-2的7次方，即128，依次加1，直到加到1111 1111（-1）的时候，再加1 即 1 0000 0000，取低8为就是0000 0000 ，即为0。同理减也类似
所以-128后面是127，126. ...0 -1 -2，直到循环1000次
而strlen求得的是字符串的长度，统计的是\0(ASCII码值是0）之前的字符个数，即从-1，-2...-128,127,126....1,这其中有255个数字，即程序运行结果是255，如下图
2.3.5 练习5
下面两个程序运行结果是什么
#include <stdio.h>
unsigned char i = 0;
int main()
{
for (i = 0; i <= 255; i++)
{
printf("hello world\n");
}
return 0;
}
我们知道unsigned char 的取值范围为0到255，就像上面那个转盘一样，加到255后就变为0 了，由于我对电脑自带的画图软件不熟悉，我就上传我自己在纸上画的转盘如下图所示。还有一个图借用鹏哥的图
所以该程序i的范围始终在0到255，循环会一直执行，该循环是死循环，一直在打印hello world
下图是运行结果
接下来看另一个程序
#include<stdio.h>
int main()
{
unsigned int i;
for (i = 9; i >= 0; i--)
{
printf("%u\n", i);
}
return 0;
}
和上一个程序差不多，unsigned int 表示范围为0到65535，i从9，8，7...0再减下去就变为65535，65534，一直再减到0，循环条件一直为真，程序一直处于死循环，由于最后要整形提升，从8位二进制到32位二进制，最后变为10进制，所以最后打印的数会很大，下面是运行结果，如果不手动关闭，会一直打印
2.3.6 练习6
下面程序的运行结果是什么（前提是在小端环境下）当然在大端环境下也能做，只是结果和这不一样罢了，各位可以自己课后去想想，我会把结果放在评论区。
#include <stdio.h>
int main()
{
int a[4] = { 1, 2, 3, 4 };
int* ptr1 = (int*)(&a + 1);
int* ptr2 = (int*)((int)a + 1);
printf("%x,%x", ptr1[-1], *ptr2);
return 0;
}
&a取出来的是数组的地址，&a等价于int(*)[4]，&a+1指向的是数组最后面的地址，ptr[-1]相当于*（ptr1-1),解引用ptr1是从该地址往后取一个整形，如下图所示
所以ptr[-1]的值就是4
(int)a是将数组的首元素的地址强转为int，整形类型的值加1就是加1 ，这里要和指针加1区别，指针加1，取决于指针的类型，假设（int*）a的值为0x0012ff40,0x0012ff40加1就变成0x0012ff41,所以这时用（int *)强转后是指向首元素的下一个字节，*ptr2解引用访问四个字节，具体图如下所示（要注意是小端存储）
所以此时*ptr2= 0x02000000,在16进制中x后面的0写不写都没事，下面是运行结果
3. 浮点数在内存中的存储
常见的浮点数：3.14159、1E10等，浮点数家族包括：float 、 double 、 long double 类型。浮点数表示的范围： float.h 中定义
3.1 练习
#include <stdio.h>
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;
}
这个程序的运行结果大家可以先想想，等我把浮点数在内存中的存储讲完就来回到这一题。
3.2 浮点数的存储
根据国际标准IEEE（电气和电子工程协会）754，任意⼀个⼆进制浮点数V可以表⽰成下⾯的形式：
表示符号位，当S=0，V为正数；当S=1，V为负数
M表示有效数字，M是大于等于1，小于2的
表示指数位
举例来说：
⼗进制的5.0，写成⼆进制是 101.0 ，相当于 1.01×2^2 。
那么，按照上面V的格式，可以得出S=0，M=1.01，E=2。
⼗进制的-5.0，写成⼆进制是-101.0,相当于-1.01×2^2 。那么，S=1，M=1.01，E=2。
IEEE 754规定：
对于32位的浮点数，最高的1位存储符号位S，接着的8位存储指数E，剩下的23位存储有效数字M 对于64位的浮点数，最高的1位存储符号位S，接着的11位存储指数E，剩下的52位存储有效数字M
3.2.1 浮点数存的过程
IEEE 754对有效数字M和指数E，还有⼀些特别规定。
前⾯说过， 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是可以出现负数的，所以IEEE754规定，存入内存时E的真实值必须再加上 ⼀个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。比如，2^10的E是 10，所以保存成32位浮点数时，必须保存成10+127=137，即10001001。
3.2.2 浮点数取的过程
指数E从内存中取出还可以再分成三种情况：
E不全为0或不全为1
这时，浮点数就采⽤下⾯的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将有效 数字M前加上第⼀位的1。 比如：0.5的⼆进制形式为0.1，由于规定正数部分必须为1，即将小数点右移1位，则为1.0*2^(-1)，其 阶码为-1+127(中间值)=126，表⽰为01111110，而尾数1.0去掉整数部分为0，补齐0到23位 00000000000000000000000，则其⼆进制表示形式为:
E全为0
这时，浮点数的指数E等于1-127（或者1-1023）即为真实值，有效数字M不再加上第⼀位的1，⽽是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于0的很小的数字。
E全为1
这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）
好了，到现在关于浮点数在内存中的存储以及一些细节我已经讲完了，现在我们再回头看那个题目吧
#include <stdio.h>
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，再看第二个，&n是int *类型的，将它强转为float *，然后再赋给pFloat。
n=9,我们实际上存储的是9的补码，即（用32个bit位来写）
0000 0000 0000 0000 0000 0000 0000 10001
站在pFloat的角度上来看，它会认为自己指向的是float类型的数值，会以下述方法解读
0 00000000 00000000000000000001001
S E M
当内存中的E为全0时，真实的E为1-127=-126，有效数字M取出后不再加上第一位的1，此时这个数特别小，几乎接近于0,以%f打印的时候默认打印到小数点后6位，所以第2个输出的是0.000000
再看第三个，*pFloat-9.0,站在pFloat的角度上来看，它会认为自己指向的是float类型的数值,所以此时9.0以浮点数的存储规则来存储，即此时S=0;M=1.001,E=3，即存储成
0 10000010 00100000000000000000000
然后再以整数的视角往外拿的时候，它认为这个是补码，且%d是以有符号数打印的，最高位为符号位，这个数最高位为0，正数的原码和补码相同。
即 0100 0001 0001 0000 0000 0000 0000 0000，转换成10进制就是1091567616
下面是运行结果
那么到现在，我们关于数据在内存中的存储的部分就讲完了，如果你能看到这，相信你一定会有很大的收获的，如果你有什么问题都可以在评论区问我，我看到会第一时间回复的，如果我写的有错误，也恳请各位大佬指正，那么我们下期博客再会！
扫一扫
1704
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
