C语言的数据存储

木子斤欠木同

已于 2022-11-14 10:15:02 修改

阅读量834

点赞数 3

分类专栏： C语言的基础知识文章标签： c语言

于 2022-09-11 09:29:18 首次发布

本文链接：https://blog.csdn.net/ANNE_fly/article/details/126790128

版权

C语言的基础知识专栏收录该内容

14 篇文章 3 订阅

订阅专栏

一、数据类型详细介绍

基本的内置类型有:

char 字符数据类型
short 短整型
int 整型
long 长整型
long long 更长的整型
float 单精度浮点数
double 双精度浮点数

类型的意义：

（1）使用这个类型开辟内存空间的大小（大小决定了使用范围）。

（2）决定了如何看待内存空间的视角。

1.类型的基本归类

（1）整型家族：

char

unsigned char

signed char

short

unsigned short（int）

signed short （int）

int

unsigned int

signed int

long

unsigned long （int）

signed long（int）

（2）浮点数家族：

float

double

（3）构造类型：

> 数组类型

> 结构体类型 struct

> 枚举类型 enum

> 联合类型 union

（4）指针类型：

int* pi;

char* pc;

float* pf;

void* pv;

（5）指针类型：

void表示空类型（无类型）

通常应用于函数的返回类型、函数的参数、指针类型

二、整型在内存中的存储

1.原码、反码、补码

计算机中的整数有三种表示方法、即原码、反码和补码

三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”，而数值位负整数的三种表示方法各不相同。

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

正整数的原码、反码和补码都相同

对于整型来说：数据存放内存中其实存放的是补码

为什么呢？

在计算机系统中，数值一律用补码来表示和存储。原因在于使用补码可以将符号位和数值位统一处理。

同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码和原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

2.大小端介绍

什么是大小端？

大端（存储）模式：是指数据的低位字节序的内容存放在高地址处，高位字节序的内容存放在低地址处
小端（存储）模式：把数据的低位字节序的内容存放在低地址处，高位字节序的内容存放在高地址处
也就是按大端顺序存储的数据在内存中的顺序与字节序一致；而小端存储模式就为相反。

为什么有大端和小端？

为什么会有大小端模式之分呢？这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为8bit。但是C语言中除了8bit的char之外，还有16bit的short型，32bit的int型（要看具体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如何将多个字节安排的问题，因此就导致了大端存储模式和小端存储模式的产生。

例如：一个16bit的shortx，在内存中的地址为0x0010，x的值为0x1122，那么0x11为高字节，0x22为低字节。对于大端模式。就将0x11放在低地址中，即0x0010中，0x22放在高地址中，即0x0011中。小端模式，刚好相反。

例题：百度2015年系统工程师笔试题，请简述大端字节序和小端字节序的概念，设计一个小程序来判断当前及其的字节序（10分）

答：①大端字节序：把数据的低位字节序的内容存放到高地址处，把高位字节序的内容存放到低地址处；②小端字节序：把数据的低位字节序的内容存放到低地址处，把高位字节序的内容存放到高地址处。

代码思路：

首先我们得知道指针类型的作用是什么，总共有两个作用：指针的类型决定了指针向前或者向后走一步有多大（跨过多少字节）、指针的类型决定了对指针解引用的时候有多大的权限（能操作几个字节）。那么就有个思路，我们定义一个int i = 1（对应存储在内存的二进制数为00000000000000000000000000000001）；把i的地址赋值给一个char指针，因为是char类型的指针，那么他的解引用就只能操作1个字节。我们又知道了1的大端存储模式是0x00 00 00 01，小段存储模式是0x01 00 00 00。诶，我们就可以用char型指针来解引（解引用都是从低地址到高地址）用来读取该数第一个字节的数据，数据为1，那么编译器就为小段存储模式；如果数据为0，则为大端存储模式。

代码如下：

int check_sys()
{
	int a = 1;
	char* p = (char*)&a;//int*
	return *p;//返回1表示小端，返回0表示大端
}

int main()
{
	//写代码判断当前机器的字节序
	int ret = check_sys();
	if (ret == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}

	return 0;
}

3.练习

3.1 例题1

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

（1）char 到底是signed char 还是unsigned char ？C语言标准并没有规定，取决于编译器。vs2019规定了char为signed

（2）a，b输出的值都是有符号的char，那就是直接输出了-1；而c是无符号的char型（赋值和输出都发生了隐式类型提升，char->int；真正存储到c中时是发生了类型截断。）

①-1的原码为10000000000000000000000000000001；反码为11111111111111111111111111111110；补码为11111111111111111111111111111111。

②因为c是unsigned char，那么c = 11111111。%d又要求c由有符号的整型输出，所以c就发生了整型提升为00000000000000000000000011111111（为什么是往前面补零呢？因为c是无符号型，那么就是默认符号位也就是0，就往前面补0）。

③00000000000000000000000011111111的十进制整型就是255

（3）输出结果如下：

补充下char的取值范围：

巧记口诀：超出范围的数据如果是正数，则减去256；超出范围的数据是负数，则加上256。

unsigned char的存储范围是[0,255]。

3.2 例题2

int main()
{
    char a = -128;
    printf("%u\n",a);
    return 0;
}

（1）-128的原码为1000 0000 0000 0000 0000 0000 1000 0000；反码为11111111111111111111111101111111；补码为11111111111111111111111110000000。char a在内存存储的值就为10000000。

（2）%u是以无符号形式输出的十进制整型，也就是a在输出时发生了整型类型提升，因为char a是由符号的，所以就往前补1，值就为11111111111111111111111110000000，该值对应的十进制数就是4294967168。

（3）总结：通过例1和例2的观察发现，输出的样子是什么由格式字符%d或者%u控制，也可以由char是否有符号来控制输出结果。如果是%d与unsigned char在一起，那么重点就在无符号char，毕竟%d和unsigned char两者都要满足，unsigned char感觉上是%d的真子集，所以就看最小的。当%u和signed char在一起时，就看%u，此时%u是signed char的真子集，就看%u了。（打印看printf，内存看类型）

（4）结果如下：

3.3 例题3

int main()
{
	char a = 128;
	printf("%u\n", a);
	return 0;
}

（1）例3把a的值换成了正的128，还是一样的分析。128是正数，所以原码反码补码相同，都是0000 0000 0000 0000 0000 0000 1000 0000，存储到a中就为10000000

（2）%u是以无符号形式输出的十进制整型，也就是a在输出时发生了整型类型提升，因为char a是由符号的，所以就往前补1，值就为11111111111111111111111110000000，该值对应的十进制数就是4294967168。

（3）结果如下：

3.4 例题4

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

（1）i为有符号的int，-20的原码为1000 0000 0000 0000 0000 0000 0001 0100；反码为1111 1111 1111 1111 1111 1111 1110 1011；补码为1111 1111 1111 1111 1111 1111 1110 1100存储到i的值也就是补码。unsigned int j，10的原码为0000 0000 0000 0000 0000 0000 0000 1010，补码也是该值。

（2）i + j就是补码相加

i：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 1111 0110（该值为负数，需要转换为原码）

对应的反码：1111 1111 1111 1111 1111 1111 1111 0101；对应的原码：1000 0000 0000 0000 0000 0000 0000 1010，该值就是-10

（3）结果如下：

3.5 例题5

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

结果为死循环！

（1）i为无符号的i，那么也就是说无论i怎么减小，都不可能为负的

（2）结果如下：

3.6 例题6

int main(){
	char a[1000];
	int i;
	for (i = 0; i < 1000; i++){
		a[i] = -1 - i;
	}
	printf("%d", strlen(a));
	return 0;
}

（1）strlen()函数是检测到'\0'（或者0）就结束；知道了char数据类型的性质。

（2）循环体运行：-1、-2、-3、-4、……、-128、127、126、125、……、1、0

（3）到0之前有几个字符呢，有-1~-128,1~127，也就是128+127==255

（4）结果如下：

3.7 例题7

int main()
{
	unsigned char i = 0;
	for (i = 0;i <= 255;i++)
	{
		printf("hello world\n");
	}
	return 0;
}

（1）unsigned char和signed char一样都是循环数据，范围是[0,255]

（2）for循环的条件是i<=255，unsigned char的数都满足，所以出现了死循环

（3）结果如下：

三、浮点数在内存中的存储

1.浮点数存储规则

根据国际标准IEEE（电气和电子工程协会）754，任意一个二进制浮点数V可以表示成下面的形式：

（-1）^ S * M * 2 ^ E
（-1）^ S表示符号位，当S=0，V为正数；当s=1，V为负数
M表示有效数字，大于等于1，小于2.
2 ^ E表示指数位

IEEE 754规定：

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

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

举例来说：

十进制的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对有效数字M和指数E，还有一些特别规定。

前面说过， 1≤M<2 ，也就是说， M 可以写成 1.xxxxxx 的形式，其中 xxxxxx 表示小数部分。 IEEE 754规定，在计算机内部保存M 时，默认这个数的第一位总是 1 ，因此可以被舍去，只保存后面的 xxxxxx部分。比如保存 1.01的时候，只保存 01 ，等到读取的时候，再把第一位的 1 加上去。这样做的目的，是节省 1 位有效数字。以 32 位浮点数为例，留给 M 只有 23位。将第一位的1舍去以后，等于可以保存 24 位有效数字。没满23位或者52位就往后面补0。

至于指数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从内存中取出还可以分成三种情况

（1）E 不全为 0 或不全为 1

这时，浮点数就采用下面的规则表示，即指数 E的计算值减去127（或1023），得到真实值，再将

有效数字M前加上第一位的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。

（2）E全为0

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

（3）E全为1

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

2.加深印象

举个栗子：

上点强度：

（1）第①行中的n本来的类型就是int，所以以%d（有符号的整型输出）输出时，就是原本的值9.

（2）第②行中是用float *pFloat指向了&n的地址（也是进行了强转），*pFloat和也是%f输出，二进制9：0000 0000 0000 0000 0000 0000 0000 1001。解读S = 0，E = 0000 0000，M = 000 0000 0000 0000 0000 1001；此时就遇到了E的特殊情况——E全为0的情况，这时有效数字M就不再加上第一位的1，还原为0.0000000000000000001001（十进制：0.0000021457672119140625）的小数；E = 1 - 127= -126。

则为：(-1)^0 * 0.0000021457672119140625 * 2^(-126)无效接近于0，float显示出来的是小数点后六位，再后面就看不到了。

（3）*pFloat是用float的视角来存储9.0，所以就是二进制1001，S = 0，M = 1.001，E = 3 + 127。内存中存储就是0 1000 0010 00100000000000000000000。第③行中是用%d输出的int n，也就是从整型的视角出发，结果就是1,091,567,616。（存储看类型，输出看格式字符）

（4）第④行是用%f输出，*pFloat又是从Float的视角出发也就是9.000000