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。