1、整形存储和大小端
本章重点：
1、数据类型详细介绍
2、整型在内存中的存储：原码、反码、补码
3、大小端字节序介绍及判断
4、浮点型在内存中的存储解析
1.1、数据类型介绍
char 1byte //字符数据类型
short 2byte //短整型
int 4byte //整形
long 4/8byte //长整型 在32位平台下是4byte，在64位平台下是8byte
long long 8byte //更长的整形
float 4byte //单精度浮点数
double 8byte //双精度浮点数
//C语言规定：sizeof(long) >= size(int)
//C语言没有字符串类型，只有字符类型
类型的意义：
- 使用这个类型开辟内存空间的大小（大小决定了使用范围）。
- 如何看待内存空间的视角。
1.2、类型的基本归类
整型家族：
char //字符的本质是ASCII码值，是整型，所以划分为整形家族
unsigned char 0~255 ，如果unsigned char a = 1945，最后也会分解为0~255之间的数，下面的同理，无论赋值多少，都不会跳出它们所对应的范围。
signed char -128~127
short
unsigned short [int] 0~65535
signed short [int] -32768~32767
int
unsigned int
signed int
long
unsigned long [int]
signed long [int]
long long
unsigned long long [int]
signed long long [int]
有几个点需要说一下：
-
平常我们使用int是，int a; ------> signed int a;
-
char分为三种类型：char，signed char，unsigned char。那char到底是signed char还是unsigned char呢？标准是未定义的，取决于编译器。VS编译器是signed char
-
signed—有符号整型，既有正数又有负数。
-
unsigned—无符号整型，只有正数。
如果是signed，需要看最高位（符号位），如果符号位是0，就为正数，如果符号位是1，就为负数。
__浮点数家族：__表示小数就可以使用浮点型。
float //精度低，存储数值的范围较小
double //精度高， 存储数值的范围较大
构造类型（自定义类型）：
> 数组类型
> 结构体类型 struct
> 枚举类型 enum
> 联合类型 union
数组类型：只要是元素类型和元素个数不同，在就是不同类型的数组。
eg：
- int arr[5]; 这个数组的类型是int [5]。
- int arr[8]; 这个数组的类型是int [8]。
- char arr[5]; 这个数组的类型是char [5]。
指针类型：
int* pi;
char* pc;
float* pf;
void* pv;
空类型：
void表示空类型（无类型）
通常用于函数的返回类型、函数的参数、指针类型。
//第一个void表示函数不会返回值，第二个void表示函数不需要任何传参。
void test(void)
{
;
}
2、整型在内存中的存储
我们之前讲过一个变量的创建是要在内存中开辟空间的。空间的大小是根据不同的类型而决定的。
那接下来我们来看看数据在所开辟内存中到底是如何存储的？
比如：
int a = 10;
int b = -10;
我们知道a分配4个字节的空间。
那如何存储？
如下了解下面的概念：
2.1、原码，反码、补码
整数的二进制表示有3种：
- 原码
- 反码
- 补码
正的整数的原码、反码、补码相同。
负的整数的原码、反码、补码是要计算的：
- 原码：直接通过正负的形式写出的二进制序列就是原码。
- 反码：原码的符号位不变，其它位按位取反得到的就是反码。
- 补码：反码+1就是补码。
1、比如7的原码、反码、补码：
因为7是正值所以，原码 = 反码 = 补码
7是int类型的，占4个字节，一个字节=8bit，所以：
原码 = __0__0000000000000000000000000000111
注意：最高位（就是最左边的哪一位）0代表是正数，1代表是负数。
2、-7的原码、反码、补码
- 原码：10000000000000000000000000000111
- 反码：11111111111111111111111111111000（按照原码的最高位不变，其它的取反）
- 补码：11111111111111111111111111111001（反码+1=补码）
我们知道数值有不同表示方式：
- 2进制
- 8进制
- 10进制
- 16进制
现在我们来用不同的表达方式来表示十进制的21：
- 2进制：__0b__10101 ，0b代表二进制
- 8进制：__0__25 ，0代表八进制
- 16进制：__0x__15 ，0x代表十六进制
现在我们来分别计算如下程序的原码，补码，反码：
#include <stdio.h>
int main()
{
int a = 20;
//20
//原码==反码==补码 --> 00000000000000000000000000010100
int b = -10;
//10
//原码 --> 100000000000000000000000000001010
//反码 --> 111111111111111111111111111110101
//补码 --> 111111111111111111111111111110110
return 0;
}
【补充一点：】这里我们在使用编译器调试的时候来看，其实是把__每4个二进制位转为一个16进制位的。__
也就是说数据是以16进制的形式来展示给程序员的。
比如：上述的20的补码：00000000000000000000000000010100
所以20的二进制转为十六级进制就为：0x00000014
同理-10：
- 原码：0x800000000a
- 反码：0xfffffff5
- 补码：0xfffffff6
下面我们进入调试，来看一下：
注意：千万不要认为调试的时候显示的是十六进制的数据，那在内存中存储的形式就是十六进制的。这是错误的，实际上在内存中存储的形式还是二进制的。只不过是二进制的数据需要32bit，看着不方便，不简洁，然后编译器就以每4个二进制位转为十六进制位的方式进行存储的。千万千万要注意这一点。
2.2、得出结论：整型内存中存放的是补码的二进制序列。
其实从&b那张图就可以看出：整型内存中存放的是补码的二进制序列。
那为什么内存中存放的是补码呢？
在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统一处理。
同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。
CPU只有加法，那减法怎么处理呢？比如：1-1？
其实1-1可以写为1+(-1)，这样就完美转换为加法了。这也就是上述所说的加法和减法可以统一处理的实现。
现在我们就是是一下1+(-1)吧
首先 1的补码：00000000000000000000000000000001
然后-1的补码：11111111111111111111111111111111
然后两个补码相加为：100000000000000000000000000000000（这个变为33位了，因为进位+1了）
但是int类型的大小只有32bit，所以只取32bit个：00000000000000000000000000000000。
所以1+(-1)最终结果就是0。
补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。这句话怎么理解呢？
我们知道负数：原码取反得到反码，然后反码+1得到补码。
那如果我们由补码得到原码？大多数人想到的就是：这简单呀，就是：补码-1得到反码，然后反码取反得到原码。
这样就搞定了。对！！！这种方法是可行的，是正确的。
但其实还有另一种方法，就是：补码取反得到反码，然后反码取反得到补码。
也就是说由原码得到补码，或者是由补码得到原码的动作是相同的。
举个例子：-10
-10的补码：11111111111111111111111111110110，然后补码+1得到反码
-10的反码：11111111111111111111111111110111，然后反码取反得到原码
-10的原码：10000000000000000000000000001000。
所以又得到原码=-10了。
所以上补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。
2.3、大小端
问题引入：如下图，有没有发现数据在存储的时候是倒着存储的呢？得到的数据是0x00000014，存储的是0x14000000。这里就牵扯到大小端问题。
什么是大小端：
大端（字节序存储），是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中；
小端（字节序存储），是指数据的低位保存在内存的低地址中，而数据的高位，保存在内存的高地址中。
【说明：】0x11223344，这里的44是数据的最低位，11是数据的最高位。
我们需要知道数据在存储时，有个顺序问题。
所以可以看出VS的编译器是小端存储的。
2.4、百度2015年系统工程师笔试题
请简述大端字节序和小端字节序的概念，设计一个小程序来判断当前机器的字节序。
分析：我们就去一个简单的数字，比如：int a = 1; 这里的取值可以任意取，只不过取1可以更简单，更直观的体现出来大小端。
如果是小端字节序，应该是这样存储的：
如果是大端字节序，应该这样存储的：
可以发现大小端字节序的区别就是：第一个字节的值不一样，我们就根据这一点来判断即可。
如下代码：
#include <stdio.h>
int main()
{
int a = 1;
if (*(char*)&a == 1)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
return 0;
}
//封装为函数的写法
#include <stdio.h>
int check_sys()
{
int a = 1;
return *(char*)&a;
}
int main()
{
int a = 1;
int ret = check_sys();
if (ret == 1)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
return 0;
}
3、练习题
第一题：打印以下结果
#include <stdio.h>
int main()
{
char a = -1;
signed char b = -1;
unsigned char c = -1;
printf("%d %d %d\n", a, b, c);
return 0;
}
//signed char -128~127
//unsigned char 0~255
分析：首先-1是整型，但现在是char类型所以需要截断。
-1的原码：10000000000000000000000000000001
-1的反码：11111111111111111111111111111110
-1的补码：111111111111111111111111__11111111__
然后截断，只取上面补码加黑部分。
所以char类型的-1就是11111111。
然后看打印，打印要求是以%d的形式输出，%d代表是int类型的，那由char类型的到打印int类型的需要整型提升。
但是现在是char类型的数据，所以需要整型提升。
那现在需要对a进行整型提升，我们需要先看a的类型，a的类型是char，char是有符号char，所以最高位就是符号位。
既然是有符号char，那整型提升就是：高位需要用符号位进行填充。
所以a整型提升后位：11111111111111111111111111111111，这个二进制序列是补码。但是需打印原码，所以还需要转为原码。
补码：11111111111111111111111111111111
反码：10000000000000000000000000000000
原码：10000000000000000000000000000001
所以记结果就是-1。
所以a输出的结果就是-1。又因为这里的char就是signed char，所以b的结果也是-1。
现在来分析c的值。
首先：unsigned char c = -1; 由于unsigned char的取值范围是0~255，按理说c不能为-1，超出范围了。
按理说不能存，但是实际上是先存进去的。
-1的原码：10000000000000000000000000000001
-1的反码：11111111111111111111111111111110
-1的补码：11111111111111111111111111111111
因为-1是整型，但是c是char类型的，所以需要截断。
截断后的补码：11111111
然后进行整型提升。先看c是什么类型的，c是unsigned char类型的，是无符号类型的char，所以说这里高位不要用符号位填充了。高位直接用0进行填充。
所以整型提升后得补码为：00000000000000000000000011111111
而此时的补码就等于原码。所以结果为255。
第二题：打印以下结果
#include <stdio.h>
int main()
{
char a = -128;
printf("%u\n", a);
return 0;
}
输出：
分析：首先a=-128
a的原码：10000000000000000000000010000000
a的反码：11111111111111111111111101111111
a的补码：11111111111111111111111110000000
因为a是char类型的，所以需要截断。
截断后的补码：10000000
然后由于是以%u进行输出，%u代表无符号整型。所以重点是char类型的想以int类型的打印，需要整型提升。
整型提升后的补码：11111111111111111111111110000000
这时再看打印，要求以%u进行打印输出。因为%u是无符号整型打印。不存在符号位了，补码就是反码就是原码。
所以结果为：4294967168。
第三题：输出程序结果
#include <stdio.h>
int main()
{
int i = -20;
unsigned int j = 10;
printf("%d\n", i+j);
return 0;
}
输出：
分析：首先因为都是整型，所以不需要整型提升了
-20的原码：10000000000000000000000000010100
-20的反码：11111111111111111111111111101011
-20的补码：11111111111111111111111111101100
10的补码：00000000000000000000000000001010
i+j;就等于-20的补码+10的补码：
11111111111111111111111111101100
00000000000000000000000000001010
相加之后的结果：11111111111111111111111111110110
因为要以%d打印，%d是有符号整型。最高位为符号位=1，所以为负数，应该求反码，原码。
得到反码：10000000000000000000000000001001
得到原码：10000000000000000000000000001010
所以结果为-10。
第四题：输出程序结果
#include <stdio.h>
#include <Windows.h>
int main()
{
unsigned int i;
for (i = 9; i >= 0; i--)
{
printf("%u\n", i);
Sleep(1000);
}
return 0;
}
输出 9 8 7 6 5 4 3 2 1 0就不说了，这个是正常的程序。
说一下为什么会打印下面的数：当i=0之后，i–，i变成-1。
但是i是unsigned int类型的。i现在是负数，需要经过反码，补码，然后求其值
-1的原码：10000000000000000000000000000001
-1的反码：11111111111111111111111111111110
-1的补码：11111111111111111111111111111111
-1的补码转为十进制就为：4294967295
显然这个数是>=0的。所以条件满足，然后打印输出。
然后i–，i变为了-2，也是同样的道理。
第五题：填写结果
#include <stdio.h>
#include <string.h>
int main()
{
if (strlen("abc") - strlen("abcdef") >= 0)
{
printf(">\n");
}
else
{
printf("<\n");
}
return 0;
}
输出：
分析：
-
错误的思路：strlen(“abc”)返回值=3 strlen(“abcdef”)返回值=6。3-6=-3<0成立，不应该输出
<。其实这样想是错的 -
正确思路：其实strlen返回的数据类型是size_t，也是就是unsigned int类型的，因为unsigned int - unsigned int得到的还是个unsigned int类型的值，所以就变成了unsigned int -3的。又因为unsigned int的取值范围是>=0恒成立的。所以说unsigned int -3最终还是被分解为大于0的数，所以打印
>。
4、浮点型在内存中的存储
首先：一个数据以整型的方式进行存储，那么读取的时候还应该以整型的方式取读取。同理一个数据以浮点型的方式进行存储，那么读取的时候还应该以浮点型的方式取读取。切不可混乱使用，比如：一个数据以整型的方式进行存储，读取的时候以浮点型的方式进行读取，这样是不可取的。
4.1、浮点数存储的规则
4.1.1、存放浮点数
详细解读：
根据国际标准IEEE（电气和电子工程协会）754，任意一个二进制浮点数V可以表示成下面的形式：
(-1)^S * M * 2^E。
(-1)^S表示符号位，当S=0，V为正数；当S=1，V为负数。
M表示有效数字，大于等于1，小于2。
2^E表示指位数。
浮点数存储只要是存储S、M、E等数字就可以把一个浮点数给存储下来。
示例一：
//5的二进制数值是101 //2^2--->2的2次方,第一个2是二进制，
//第二个2是小数点向左移动了2位
//123.45科学计数法--->1.23*10^2
V = 5.0f ---转为二进制---> 101.0 ---转为科学计数法---> 1.01*2^2
= (-1)^0 * 1.01 * 2 ^ 2
S=0、M=1.01、 E=2
示例二：V = 9.5f这个怎么表示呢？是这样的吗：1001.101？这个写法是错误的。
应该写为：1001.1 因为小数点后面的权重为，2的-1次方，2的-2次方，2的-3次方…
因为2的-1次方正好是0.5，所以说二进制的.1就是十进制的.5。
V = 9.5f
= 1001.1
= 1.0011 * 2 ^ 3
= (-1)^0 * 1.0011 * 2 ^ 3
= S=0、 M=1.0011、 E=3
经过两个示例我们可以意识到，存储浮点数，只要把S、M、E等存储下来，就可以把浮点数存储下来。
但是我们要知道有些浮点数是存储不准确的，比如：V = 9.6f 这个0.6无论如何总会有偏差的。
IEEE 754规定：
对于32位的浮点数，最高的1位是符号位S，接着的8位是指数E，剩下的23位为有效数字M。
对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M。
上图说明：要把S、M、E的值全部转为二进制，然后拼凑在一起得到一个32bit/64bit的二进制序列，把这个二进制序列存起来，那就是该小数的值。
那具体S、M、E是怎么存的呢？如下：
S其实很好存储，无非就是0或者1。复杂的是M和E。
IEEE 754对有效数字M和指数E，还有一些特别的规定：
- 有效数字M：
- 指数E，情况比较复杂：
指数E：简而言之就是，如果是float类型的，真实指数E需要+127（中间值）得到一个存储E，这个+127之后得的存储E的结果才是存储到内存里面的E。
如果是double类型的，真实E需要+1023得到一个存储E，这个+1023之后得的存储E的结果才是存储到内存里面的E。
那么下面来写个程序验证以下：
#include <stdio.h>
int main()
{
float f = 5.5f;
//5.5
//101.1
//1.011 * 2 ^ 2
//s=0,m=1.011,e(真实的e)=2
//s取0 m只取小数部分：011 e+127=129 ---> 10000001 --->得到存储e
//好的，现在把s、e、m按照顺序拼凑在一起：010000001011
//得到了：010000001011，但是这个不够呀，folat数32bit位的，所以其余的补0
//最终得到该小数的存储：01000000101100000000000000000000
//为了等会便于观察，把每4个二进制位转化为1个16进制位：0x40b00000
//调试，在是否存储的是0x40b00000。（这里存在大小端问题，所以可能是倒放的数据）
return 0;
}
4.1.2、拿取浮点数数据
指数E从内存中取出还可以再分为三种情况：
-
E不全为0不全为1的情况下拿取该小数（常规情况，怎么放进去的，然后反向操作在拿出来即可。）
这个还拿上面的那例子演示：
最终得到该小数的存储：01000000101100000000000000000000 S部分为0 E部分为10000001---129，然后-127 得到2 M部分为01100000000000000000000，然后在前面添个1，变成：1.01100000000000000000000 之后拿取该小数：(-1)^0 * 1.01100000000000000000000 * 2 ^ 2。
- E为全0
- E为全1
4.1.3、举个例子
#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;
}
输出：
分析：
-
第一个printf()不在解释很常规。
-
第二个printf()：9的补码：00000000000000000000000000001001，现在以*pFloat来看，左侧的补码二进制序列是folat类型的，所以S=0、M=00000000000000000001001，E全为0的情况，E=-126。
那计算值：S(0)00000000000000000001001 * 2 ^ (-126) = 00=0，所以最终结果为0。
-
第三个printf()：*pFloat = 9.0;
= 1001.0
= 1.001 * 2 ^ 3
= (-1)*0 * 1.001 * 2 ^ 3 —> S=0、M=1.001、E=3
真实E+127=存储E=130—>100000010
M—>00100000000000000000000
= 010000001000100000000000000000000
好了，现在以n的角度打印，010000001000100000000000000000000，最高位是0，那是补码呀，然后就直接计算出了值，最终值为：1091567616
-
第四个printf()：以浮点型存储，以浮点型读取，所以结果就是9.00000000。
