重点

• 1. 数据类型详细介绍
• • • 整数类形
    • 浮点型
    • 构造类型
    • 指针类型
    • 空类型
• 2. 整形在内存中的存储
• • • 原码、反码、补码
    • 整形存储补码的原因
• 3. 大小端字节序介绍及判断
• 练习题（含笔试题）
• 4. 浮点型在内存中的存储

1. 数据类型详细介绍

到目前为止，我们已经掌握了C语言的基本内置类型，如下：

char        //字符数据类型 (1 byte)
short       //短整型 (2 byte)
int         //整形 (4 byte)
long        //长整型 (4/8 byte)
long long   //更长的整形 (8 byte)
float       //单精度浮点数 ( 4byte)
double      //双精度浮点数 (8 byte)

每一种数据类型的大小不同，这也就决定了它所存储的数据范围也就不同，就比如char和int所存储的数据范围就不同，那么具体能存储多少呢？相信大家看完本本章内容，就能对每一种数据是怎么存储在内存中的，就会有了更加深刻的认识。

首先，在C语言里我们把类型分为以下几种：1、整数类型 2、浮点型
3、构造类型（自定义类型） 4、指针类型 5、空类型

整数类形

//unsigned：无符号类型  signed：有符号类型
char
 unsigned char
 signed char
short
 unsigned short [int]
 signed short [int]
int
 unsigned int
 signed int
long
 unsigned long [int]
 signed long [int]

在这里，unsigned是表示无符号类型，signed表示有符号类型，所谓无符号类型就是这个数没有负数，只有正数和0，而有符号就表示这个数有正有负，大家来看这么一个例子：

从这里就可以看出，这里的c明明赋值为-1，但是存储的却显示出一个很大的正数，这是因为c是一个unsigned类型的整数，而这里，我们平常书写的一些int，short、char，这其实都是signed int、signed short、signed char，只不过signed都被省略了。

浮点型

float
double

具体区别会在后面讲到

构造类型

构造类型又叫自定义类型，主要包括：数组、结构体类型（struct）、枚举类型（enum）、联合类型（union）

#include<stdio.h>
	//结构体
	struct book
	{
		char name[20];
		int price;
	};
	//枚举enum即enumerate的缩写，意思就是列举
	enum color { red = 1,blue = 2 };
	int main()
	{
		//数组
		int arr[] = { 1,2,3,4,5 };
		struct book str = { "C语言程序设计",50 };

		printf("%s %d\n",str.name,str.price);
		printf("%d %d\n", red, blue);
		return 0;
	}

这里要注意一点，就是结构体成员访问时，结构体变量名.结构体成员、结构体变量地址（指针）->结构体成员。

指针类型

int* p1;
char* p2;
float* p3;
void* p4;

这里需要注意一点，就是void*，它可以接受任意类型的指针，就像一个垃圾桶一般，char*，int*，short*等都可以接受，但是，正是因为啥都可以接收，所用它不能直接解引用，或者进行指针的运算，毕竟我们不确定到底接受的是几个字节。

如果想要对void*类型进行解引用或者运算的话，必须先强制类型转换，才可以使用，如下：

#include<stdio.h>

int main()
{
	int a = 10;
	void* p = &a;
	//强制类型转换为int*类型，再解引用
	*(int*)p = 50;

	printf("%d", a);
	return 0;
}

空类型

空类型经常用到函数的返回类型以及函数参数中

#include<stdio.h>
//这里的返回类型以及参数都是void空类型
void test(void)
{
	printf("123");
}

int main()
{
	test();
	return 0;
}

了解这些内容后，接下来开始讲解整形在内存中是如何存储的

2. 整形在内存中的存储

我们知道，任何变量的创建都需要在内存中开辟一块空间，空间的大小是由它们的类型决定，那么，这些数据是如何在内存中存储的呢？且听以下讲解
首先我们要先了解到原码、反码、补码

原码、反码、补码

计算机中的整数有三种2进制表示方法，即原码、反码和补码。
三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”，正数的原、反、补码都相同。
负整数的三种表示方法各不相同。

原码
直接将数值按照正负数的形式翻译成二进制就可以得到原码。
反码
原码符号位不变，其余取反得到反码
补码
反码+1得到补码

整形存储补码的原因

对于整形来说：数据存放内存中其实存放的是补码。
因为使用补码，可以将符号位和数值域统一处理，同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。
具体如下图：

我们可以看到，如果存放的是原码，计算的结果会有很大偏差，更别说反码了。

为什么说补码与原码相互转换，其运算过程是相同的呢？

所以，整形在内存中存储的是补码

3. 大小端字节序介绍及判断

我们知道，整形在内存中存储的是补码，大家再来看，假如要存储-10

#include<stdio.h>

int main()
{
	int a = -10;

	return 0;
}

然而通过调试我们发现，存储的是f6 ff ff ff，这是为什么呢？这里就涉及到了大小端字节序的存储
大端（存储）模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址
中；
小端（存储）模式，是指数据的低位保存在内存的低地址中，而数据的高位,，保存在内存的高地
址中。

大家可以看到，这里vs的存储模式就是小端存储，因为它把低位的数据存储到内存的低地址，把高位存储在高地址。这里万万不可写成6f ff ff ff ，因为f 6占一个字节。

练习题（含笔试题）

习题1：

百度2015年系统工程师笔试题：
请简述大端字节序和小端字节序的概念，设计一个小程序来判断当前机器的字节序。

思路：这里我们只需要知道它的低地址处存储的是不是低位的数据，就可以判断是不是大小端了，就比如，如果是个int类型的数字，1，它的存储的补码为：00 00 00 01（16进制方便调试观察），低地址假如是01，就说明是小端，反之大端。完整答案如下：

小端字节序存储：把一个数值的低位字节内容存放到内存低地址处，高位字节内容存放到内存高地址处。
大端字节序存储：把一个数值的低位字节内容存放到内存到高地址处，高位字节内容存放到内存低地址处。
小程序如下：

#include <stdio.h>
int check_sys()
{
	int i = 1;
	//把i地址强制类型转换为char*（解引用只能访问1个字节），因为我们只需要看低地址的字节存储，然后解引用指向第一个字节存储的内容，
	return (*(char*)&i);
}
int main()
{
	//判断
	int ret = check_sys();
	if (ret == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}

习题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;
}

且看分析：

重点来分析这个unsigned char c

所以，最终的结果为-1 -1 255

习题3：

#include <stdio.h>
int main()
{
char a = -128;
printf(“%u\n”,a);
return 0;
}

%u：打印无符号整型，认为内存中存放的补码对应的是一个无符号数。
%d：打印有符号整型，认为内存中存放的补码对应的是一个有符号数。

-128存储在内存中的补码为1000 0000(截断)，打印无符号整数时，整型提升，char为有符号数，高位补符号位，即11111111 11111111 11111111 10000000，由于是打印无符号的整型，所以就是打印这个数对应的十进制

我们用计算器，可以算出，这个数对应的十进制是4294967168，打印结果是否如我们所想呢？

我们发现，确实如此。

习题3：

#include <stdio.h>
int main()
{
char a = 128;
printf(“%u\n”,a);
return 0;
}

这里的a在内存中存储的是1000 0000（截断），打印时高位补符号位，这里由于发生了截断，符号位变成了1，所以整形提升后的补码为：11111111 11111111 11111111 10000000，打印结果依然是那个很大的数字。

习题4：

int i= -20;
unsigned int j = 10;
printf(“%d\n”, i+j);
//按照补码的形式进行运算，最后格式化成为有符号整数

习题5：

unsigned int i;
for(i = 9; i >= 0; i - -)
{
printf(“%u\n”,i);
}

这里，我们注意，i为无符号整型，前面正常打印，9 8 7 6 5 4 3 2 1 0，但是当i=0的时候，执行完打印命令后还会进行i- -，i此时变成了-1，注意！i是无符号整形，-1对应的无符号整数是一个很大的正数，所以循环还会一直进行下去，陷入死循环！

相信到这里，应该对整形的存储有了较为清晰的认识。接下来讲解以下浮点型是如何在内存中存储的。

4. 浮点型在内存中的存储

像float、double、long double…都属于浮点型，接下来将探究浮点型是如何在内存中存储的。

先来看这样一段代码：

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;
}

看到这个结果，相信很多人和我一样都很吃惊，那么为何会这样呢？且听以下讲解

根据国际标准IEEE（电气和电子工程协会） 754，任意一个二进制浮点数V可以表示成下面的形式：
(-1)^S * M * 2^E
(-1)^S表示符号位，当S=0，V为正数；当S=1，V为负数。
M表示有效数字，大于等于1，小于2。
2^E表示指数位。

具体是什么意思呢？

举例来说：
十进制的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。

再举个例子：
v=5.5
二进制101.1 即1.011*2^2，S=0,M=1.011,E=2

IEEE 754规定：
对于32位的浮点数，最高的1位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。

什么意思呢？具体如下：

对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M。

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位有效数字。

举个例子，也就是说，在存储5.5即101.1时，M=1.011,但是存储时只存储1后面的011，等读取的时候，再给011加上1即可1.011

至于指数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。

举个例子，假如存储float 5.5，还有double -5.5，应该这样存储：

具体真的是这样存储的吗，我们来验证一下，就拿上面的5.5来说，存储的二进制为：
0100 0000 1011 0000 0000 0000 0000 0000 转换成16进制即
40 b0 00 00
我们前面已经知道，vs是小端存储，所以存储的应该是00 00 b0 40 ，我们通过调试来验证一下：

由此可见，确实如此！
那么，该如何读取呢？指数E从内存中取出还可以再分成三种情况：
1、E不是全0，也不是全1
读取时先将E-127（1023）,然后在前面有效数字M前面加个1
就比如读取上面的0 10000001 011 0000 0000 0000 0000 0000

首先S=0，E-127得到2，然后再011前面加个1，即1.011
就可以写成（-1）^01.0112 ^2 即1.011*2 ^2
也就是101.1，转换成十进制5.5

2、E全为0
这时，浮点数的指数E等于1-127（或者1-1023）即为真实值，
有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于
0的很小的数字。

因为-127+127才等于0，也就是00000000，即E=-127，也就是说原本的数是写成x.xxx*2^-127，这个数已经非常非常非常非常小了，2的-127次方，无限趋近于0

3、E全为1
这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）

大家来想一下，128+127=255，也就是E全为1，即11111111，也就是说E=128,即原来的数是x.xx*2^128，这个数如果是正数，就超级超级超级大，趋近于正无穷，如果是个负数，就非常非常小，趋近于负无穷！

学完后我们回过头来再来看那个题：

首先，n的二进制数为：
00000000000000000000000000001001（原、反、补）
然后第一个打印，%d打印出来9，没毛病

第二个打印，这里pFloat指向的是n的地址，也就是这个二进制数，而以浮点型的视角来看待这块二进制数，这里的0就表示S,00000000表示E，后面的表示M，
这里E为全0，在上面就讲到了，当 E为全0时表示的是一个无限接近0的数字0.0000000000000000000000000000000…，所以打印出来的是0.00000000

后面pFloat=9.0，这里我们写出它存储的二进制位
9.0二进制：1001.0，即1.0012^3
S=0,M=1.001,E=3
所存储的二进制应为：
0 10000010 001 00000000000000000000
而假如以%d形式打印，我们就要把这个二进制数看成是补码
而看成补码的话，0符号位为正，原反补相同，所以对应原码为
01000001000100000000000000000000
而这个原码对应的十进制数为：1,091,567,616
所以第三个打印为1,091,567,616

第四个打印是以%f打印，打印浮点型小数，所以打印结果还是9.0

因此，输出结果为：9
0.00000000
1,091,567,616
9.0

结果确实如此，以上为数据在内存中的存储详解，期待您的支持！

望诸君加油，不负自己！