一、数据的存储

1. 数据类型介绍

类型的意义：

  1. 使用这个类型开辟内存空间的大小（大小决定了使用范围）。
  2. 如何看待内存空间的视角。

1.1 类型的基本归类

整型家族：

1
2
3
4
5
6
7
8
9
10
11
12
char
    unsigned char
    signed char
short
    unsigned short
    signed short
int
    unsigned int
    signed int
long
    unsigned long [int]
    signed long [int]

浮点数家族：

1
2
float
double

构造类型：

1
2
3
4
数组类型
结构体类型 struct
枚举类型 enum
联合类型 union

指针类型：

1
2
3
4
int* pi;
char* pc;
float* pf;
void* pv;

空类型：

void表示空类型（无类型）

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

2.整型在内存中的存储

变量的创建实在内存中开辟空间，空间的大小根据不同的类型而决。

2.1 原码、反码、补码

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

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

原码

直接将二进制按照正负数的形式转换成二进制就行。

反码

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

补码

反码+1就得到补码。

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

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

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

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

2.2 大小端介绍

什么是大端小端：

大端（存储）模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中；

小端（存储）模式，是指数据的低位保存在内存的低地址中，而数据的高位，保存在内存的高地址中。

为什么有大端和端：

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//设计一个小程序判断当前机器的字节序
#include <stdio.h>
int check_sys(){
    int i = 1;//01 00 00 00
    return (*(char*)&i);//01  1
    //char*的作用是把int类型&i转换为char类型指针，再用*取出值。
    //最后返回的为00，则为大端存储
}
int main(){
    int ret = check_sys();//01  1
    if(ret == 1){
        printf("小端\n");
    }
    else{
        printf("大端\n");
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
//union联合体实现
int check_sys(){
    union{
        int i;
        char c;
    }un;//该联合体内存分配空间为4个字节
    un.i = 1;//这里赋值un.i为1，占用4个字节。 01 00 00 00
    return un.c;//返回un.c为char类型，占用1个字节为01，返回1
}

练习：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//1.输出什么
#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;
}
//-1的原码为：10000000000000000000000000000001
//-1的反码为：11111111111111111111111111111110
//-1的补码为：11111111111111111111111111111111
//a 的补码为：11111111
//因为a为signed有符号，所以用符号位填充
//a 的%d整型提升其补码：11111111111111111111111111111111
//				反码：11111111111111111111111111111110
//				原码：10000000000000000000000000000001 所以输出为-1
//b虽然有signed有符号修饰，但和a一样
//c 的补码为：11111111
//因为c时unsigned无符号整型，所以用0扩展
//c 的整型提升其补码为：00000000000000000000000011111111 所以输出为255
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//2.
#include <stdio.h>
int main(){
    char a = -128;
    printf("%u\n", a);//%u输出无符号十进制整型
    return 0;
}
//-128的原码为：10000000000000000000000010000000
//		反码为：11111111111111111111111101111111
//		补码为：11111111111111111111111110000000
//a 的 补码为：10000000
//a这里会先的整型提升：11111111111111111111111110000000
//再用%u无符号进行输出
//输出为：4294967168
1
2
3
4
5
6
7
8
9
10
11
//3.
#include <stdio.h>
int main(){
    char a = 128;
    printf("%u\n",a);
    return 0;
}
//128的补码为：00000000000000000000000010000000
//a 的补码为：10000000
//a这里整型提升会补1：11111111111111111111111110000000
//再用%u无符号输出：4294967168
1
2
3
4
5
6
7
8
9
10
11
12
//4.
int i = -20;
unsigned int j = 10;
printf("%d\n", i+j);//输出结果为-10
//按照补码的形式进行运算，最后格式化为有符号整数
//-20的原码：10000000000000000000000000010100
//	   反码：11111111111111111111111111101011
//     补码：11111111111111111111111111101100
//  10的补码：00000000000000000000000000001010
// i+j     :111111111111111111111111111110110
//     反码：111111111111111111111111111110101
//     原码：100000000000000000000000000001010
1
2
3
4
5
6
7
8
9
10
//5.
unsigned int i;
for(i=9; i>=0; i--){
    printf("%u\n", i);
}
//输出结果：9 8 7 6 5 4 3 2 1 0 0xfffffff
//由于i为无符号整型，当最后一次i--执行变为-1时，
//-1的补码为：11111111111111111111111111111111
//故i变为正整数：0xffffffff
//因此会陷入无限循环。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//6.
int main(){
    char a[1000];
    int i;
    for(i=0; i<1000; i++){
        a[i] = -1-i;
    }
    printf("%d", strlen(a));
    return 0;
}
//当i = 128时：a[128] = -129，但是-129超出char范围，回绕为127
//当i = 129时：a[129] = -130，回绕为126
...
//当i = 255时：a[255] = -256，回绕为0
//但是当strlen会遇到'\0'停止，故输出结果为255
//补充知识点：整数0和'\0'等价，都表示空字符，'\0'是ASCII为0的字符。
1
2
3
4
5
6
7
8
9
10
11
12
//7.
#include <stdio.c>
unsigned char i = 0;
int main(){
    for(i = 0; i <= 255; i++){
        printf("hello world\n");
    }
    return 0;
}
//当最后一次i++时，i等于256，超出unsigned char i的0-255的范围
//故i = 256时，回绕为 i = 0；
//故陷入无限循环

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

常见的浮点数：

3.14159

1E10

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

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

3.1 浮点数存储的规则

根据国际标准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.01x2^2.

那么，按照上面V的格式，可以得出s=0，M=1.01，E=2.

十进制的-5.0，写成二进制是-101.0，相当于-1.01x2^2.那么，s=1，M=1.01，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位，它的取值范围为0255；如果E为11位，它的取值范围为02047.但是，我们知道，科学计数法中的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位000000000000000000000000，则其二进制表示形式为：

1
0 01111110 000000000000000000000000

E全为0

这时，浮点数的指数E等于1-127（或者1-1023）即为真实值

有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于0的很小的数字。

E全为1

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

注意：

在尾数补0时，是在右侧低位补0

由于浮点数存储方式，所以在有些小数计算时，并不是完整的小数计算，而是存在无限小数。如0.9，在二进制转换时是无限循环的，所以浮点数存储的时候会截断，实际存储的数据并不等于0.9，只能无限接近。

3.2 浮点数存储例子

1
2
3
4
5
6
7
8
9
10
11
int main(){
    int n = 9;
    float* pFloat = (float*)&n;
    printf("n的值为：%d\n", n);//9
    printf("*pFloat的值为：%f\n", *pFloat);
    
    *pFloat = 9.0;
    printf("num的值为：%d\n", n);
    printf("*pFloat的值为：%f\n", *pFloat);
    return 0;
}

解释题目输出

为什么0x00000009还原成浮点数，就成了0.000000？

将0x00000009拆分，得到第一位符号位s=0，后面8位的指数E=00000000，最后23位的有效数字M=000 0000 0000 0000 0000 1001.

1
9 -> 0000 0000 0000 0000 0000 0000 0000 1001

由于指数E全为0，所以符合上一节的第二种情况。因此，浮点数V就写成：

V=(-1)^0 x 0.0000 0000 0000 0000 0001 001 x 2^(-126)=1.001 x 2^(-146)

显然，V是一个很小的接近于0的正数，所以用十进制小数表示就是0.000000.

请问浮点数9.0，如何用二进制表示？还原成十进制又是多少？

首先，浮点数9.0等于二进制的1001.0，即1.001x2^3.

1
9.0 -> 1001.0 -> (-1)^0 x 1.001 x 2^3 -> s=0,M=1.001,E=3+127=130

那么，第一位的符号位s=0，有效数字M等于001后面再20个0，凑满23位，指数E等于3+127=130，即10000010。

所以，写成二进制形式，应该是s+E+M，即

1
0 10000010 001 0000 0000 0000 0000 0000

这个32位的二进制数，还原成十进制，正是1091567616

二进制0.1转换为十进制计算方法为：

1 * 2^(-1) = 1 * 0.5 = 0.5

就小数后第一位乘以2^(-1)，小数后第二位乘以2^(-2)，依次类推。