数据的存储

目录

1. 数据类型介绍

        1.1 类型的基本归类：

整形家族：

浮点数家族：

构造类型：（自定义）

指针类型

空类型

2. 整形在内存中的存储

2.1 原码、反码、补码

2.2 大小端介绍

什么是大端小端：

为什么有大端和小端：

练习

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

3.1 浮点数存储规则

3.2 例题

---

1. 数据类型介绍

前面我们已经学习了基本的内置类型：

char         // 字符数据类型

short       // 短整型

int         // 整形

long         // 长整型

long long   // 更长的整形

float       // 单精度浮点数

double       // 双精度浮点数

//C 语言有没有字符串类型？

以及他们所占存储空间的大小。

类型的意义：

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

2. 如何看待内存空间的视角。

1.1 类型的基本归类：

整形家族：

char

        unsigned char

        signed char

（字符在内存中存储的是字符的ASCII码值，ASCII码值是整型，所以将字符类型归类到整型家族）

char——1个字节——8个bit位

char没有明确说明默认为有符号还是无符号，是取决于编译器的。

short

        unsigned short [ int ]

        signed short [ int ]

int

        unsigned int  （无符号的）

        signed int  （有符号的）默认

int a; 就是   signed int a;

long

        unsigned long [ int ]

        signed long [ int ]

浮点数家族：

float

double

构造类型：（自定义）

> 数组类型

> 结构体类型 struct

> 枚举类型 enum

> 联合类型 union

指针类型

int * pi ;

char * pc ;

float* pf ;

void* pv ;

空类型

void 表示空类型（无类型）

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

void test(void)

{

//第一个void表示test函数不会返回任何值

//第二个void表示函数没有参数

}

2. 整形在内存中的存储

2.1 原码、反码、补码

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

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

正数的原、反、补码都相同。

负整数的三种表示方法各不相同。

原码

直接将数值按照正负数的形式翻译成二进制就可以得到原码。

反码

将原码的符号位不变，其他位依次按位取反就可以得到反码。

补码

反码 +1 就得到补码。

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

为什么呢？

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

一处理；

同时，加法和减法也可以统一处理（ CPU 只有加法器 ）此外，补码与原码相互转换，其运算过程

是相同的，不需要额外的硬件电路。

我们看看在内存中的存储：

我们可以看到对于 a 和 b 分别存储的是补码。但是我们发现顺序有点 不对劲 。

这是又为什么？

2.2 大小端介绍

什么是大端小端：

大端字节序存储，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中；

小端字节序存储，是指数据的低位保存在内存的低地址中，而数据的高位, ，保存在内存的高地址中。

为什么有大端和小端：

为什么会有大小端模式之分呢？

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

例如：一个 16bit 的 short 型 x ，在内存中的地址为 0x0010 ， x 的值为 0x1122 ，那么 0x11 为高字节， 0x22 为低字节。对于大端模式，就将 0x11 放在低地址中，即 0x0010 中， 0x22 放在高地址中，即 0x0011 中。小端模式，刚好相反。我们常用的 X86 结构是小端模式，而 KEIL C51 则为大端模式。很多的ARM ， DSP 都为小端模式。有些 ARM 处理器还可以由硬件来选择是大端模式还是小端模式。

请简述大端字节序和小端字节序的概念，设计一个小程序来判断当前机器的字节序。（10分）

int check_sys()
{
	int a = 1;
	char* p = (char*)&a;//int*

	if (*p == 1)
		return 1;
	else
		return 0;
}

//这种方式更加巧妙
int check_sys()
{
	int a = 1;
	return *(char*)&a;
}

int main()
{
	if (1 == check_sys())
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}

	return 0;
}

signed char 和 unsigned char 的轮回 

练习

1、以下程序输出什么？

#include <stdio.h>
int main()
{
    char a = -1;
            //10000000000000000000000000000001
            //11111111111111111111111111111110
            //11111111111111111111111111111111
            //11111111 - a
    signed char b = -1;
            //11111111 - b
    unsigned char c = -1;
            //11111111 - c
    printf("a=%d,b=%d,c=%d", a, b, c);
            //%d 是10进制的形式打印有符号的整数
            // a,b都为有符号的，且为负数，直接高位补符号位，即为1
            // 11111111111111111111111111111111
            // 符号位不变，取反，+1，最终结果为-1
            // 
            // c是无符号的，高位补0，
            //00000000000000000000000011111111
            //是整数，原反补一致，所以不变，答案就是255
    return 0;
}

输出结果为：-1,-1,255

2、以下程序输出什么？

#include <stdio.h>
int main()
{
    char a = -128;
    //10000000000000000000000010000000
    //11111111111111111111111101111111 取反
    //11111111111111111111111110000000 取补
    //10000000 - a
    //整型提升，由于char是有符号的，所以补符号位1
    //11111111111111111111111110000000
    //
    printf("%u\n", a);
    //%u 是10进制的形式，打印无符号的整数
    //而无符号数原反补相同，所以就是此结果，打印结果为4294967168
    return 0;
} 

%d 是10进制的形式打印有符号的整数

%u 是10进制的形式，打印无符号的整数

3、以下程序输出什么？

int main()
{
	int i = -20;
	//10000000000000000000000000010100 
	//11111111111111111111111111101011
	//11111111111111111111111111101100 补码
	//
	unsigned int j = 10;
	//00000000000000000000000000001010 原反补
	//11111111111111111111111111101100 两个加起来
	//
	//11111111111111111111111111110110 补
	//10000000000000000000000000001001 反
	//10000000000000000000000000001010 原
	printf("%d\n", i + j);//-10

	return 0;
}

 4、以下程序输出什么？

int main()
{
	char a[1000];
	//-1 -2 -3 -4 -5 .. -128 127 .. 6 5 4 3 2 1 0  
	//128 + 127 = 255
	int i;

	for (i = 0; i < 1000; i++)
	{
		a[i] = -1 - i;
	}

	printf("%d", strlen(a));
	//
	//strlen 统计的是\0之前出现的字符的个数
	//\0 - 0 \ddd
	return 0;
}

从0开始-1，有符号型的轮回。遇见0就可以停。

short - 2个字节 - 16bit

signed short：-32768~32767

unsigned short：0~65535

int - 4个字节 - 32bit

signed int ：-2147483648 ~ 2147483647 

unsigned int：0 ~ 4294967295

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

常见的浮点数：

3.14159

1E10

浮点数家族包括： float 、 double 、 long double 类型。

浮点数表示的范围： float.h 中定义

3.1 浮点数存储规则

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

V = (-1)^S * M * 2^E

(-1)^S表示符号位，当S=0，V为正数；当S=1，V为负数。

M表示有效数字，大于等于1，小于2。

2^E表示指数位。

 例如：

10进制的 5.5 ，改为2进制为

101.？

已知每一位都有权重的，所以十分位上的5的二进制就为1。

即101.1。

可看作：

（-1）^0 * 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 位有效数字。

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

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

E 全为 0

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

E 全为 1

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

3.2 例题