一、数据类型介绍
数据类型的意义：
- 使用这个类型开辟内存空间的大小（大小决定了使用范围）。
- 如何看待内存空间的视角。
1.1 类型的基本归类
整型家族
// char 虽然是字符类型，但是字符类型存储时存储的还是字符的ascii码值，所以归于整型
char
unsigned char
signed char
short
unsigned short [int] // 无符号
signed short [int] // 有符号
int
unsigned int
signed int
long
unsigned long [int]
signed long [int]
// short , int ,long ,默认都是有符号的，
// 但是 char 的是否有符号是不确定的，取决于编译器的实现。
unsigned 和 signed
我们知道，数据在内存中是以二进制的形式存储的。
unsigned 类型只能存放正数的数据
signed 类型 正负 的数据都能存放。
浮点数家族
float
double
long double
构造类型（自定义类型）
int arr[10]; // 数组类型
struct // 结构体
enum // 枚举类型
union // 联合类型
指针类型
指针类型是用来存放地址的。
int *pi;
char *pc;
float* pf;
void* pv;
空类型
void 表示空类型
通常应用于函数的返回类型、函数的参数、指针类型。
二、整型在内存中的存储
一个变量的创建是要在内存中开辟空间的。空间的大小是根据不同的类型而决定的。
那么数据在内存中到底是如何存储的呢？
下面我们就来细细分析。
首先我们要了解下面的概念：
2.1 原码、反码、补码
计算机中的整数有三种表示方法，即原码、反码和补码。
三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”。
原码
直接将一个数字按正负翻译成二进制就行
反码
将原码的符号位不变，其他位依次按位取反就可以得到了。
补码
反码 + 1得到的就是补码
正数的原、反、补码都相同
int a = 10;
// 原码：00000000000000000000000000001010
// 反码：00000000000000000000000000001010
// 补码：00000000000000000000000000001010
int b = -10;
// 原码：10000000000000000000000000001010
// 反码：11111111111111111111111111110101
// 补码：11111111111111111111111111110110
//
对于整型来说，数据在内存中是以补码的形式存放的。
在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统
一处理；
同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程
是相同的，不需要额外的硬件电路。
值得一提的是，unsigned 整型比 signed 整型 表示的正数范围大
对于 char 类型：
可以看到：
signed 类型的取值范围是：-128 ~ 127.
unsigned类型的取值范围是：1 ~ 255.
unsigned a = -10;
// -10
// 10000000000000000000000000001010
// 11111111111111111111111111110101
// 11111111111111111111111111110110
//
printf("%d",a); // %d 是打印有符号数，无论有无符号都认为是有符号数。
printf("%u",a); // %u 是打印无符号数，无论有无符号都认为是无符号数。
2.2 大小端介绍
这是16进制表示的整型 a 在内存中的存储，我们可以看到数值存储的顺序有点不对劲，这又是为什么呢？
这就要知道大小端的概念。
大小端：
大端字节序存储：是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址
中。
小端字节序存储：是指数据的低位保存在内存的低地址中，而数据的高位,，保存在内存的高地
址中。
那么该如何判断 是大端存储还是小端存储 呢？
#include<stdio.h>
//int check_sys()
//{
// // 这里只需要定义一个值为 1 的整型变量，将它赋给一个 char 类型的指针，
// // 根据 char 类型指针解引用 只能解引用头一个字节的数据，来判断大小端。
// int a = 1;
// char* pa = (char*)&a;
// if (*pa == 0)
// return 1;
// else
// return 0;
// // 0x 00 00 00 01
//}
// 进阶
int check_sys()
{
int a = 1;
return *(char*)&a;
}
int main()
{
int ret = check_sys();
if (ret)
{
printf("小端");
}
else
{
printf("大端");
}
return 0;
}
例题：
求下面代码的输出
#include<stdio.h>
int main()
{
char a = -1;
signed char b = -1;
unsigned char c = -1;
printf("%d %d %d ", a,b,c);
return 0;
}
#include<stdio.h>
// 整型提升时:
// 1. 有符号数：符号位是几，就在前面补几，补满 32 位。
// 2. 无符号数：高位直接补 0，补满 32 位。
int main()
{
char a = -1;
signed char b = -1;
// -1 的原、反、补码
// 原：10000000000000000000000000000001
// 反：11111111111111111111111111111110
// 补：11111111111111111111111111111111
//
// char 类型只能存储 8 字节数据( 取后八位 )
// 截断
// 11111111
//
// 发生整型提升：（ 符号位是几，就在前面补几，补满 32 位）
// 11111111111111111111111111111111
//
// 计算得到原码
// 100000000000000000000000000000000001
//
// 结果为： -1
//
unsigned char c = -1;
// 原：10000000000000000000000000000001
// 反：11111111111111111111111111111110
// 补：11111111111111111111111111111111
//
// char 类型只能存储 8 字节数据( 取后八位 )
// 截断
// 11111111
//
// 发生整型提升：（ 无符号数：高位直接补 0，补满 32 位。）
// 00000000000000000000000011111111
//
// 计算得到原码( 符号位是0，意味着原、反、补相同 )
// 00000000000000000000000011111111
//
// 结果为： 255
//
printf("%d %d %d ", a,b,c);
// -1 -1 255
// 打印 a,b,c 时，要发生整型提升
// %d 打印的是有符号数
return 0;
}
三、浮点数在内存中的存储
3.1 常见的浮点数
3.1415926
1E10
// 浮点数类型
float
double
long double
3.2. 浮点数存储规则
浮点数和整型数用的不是同一套存储规则。
根据国际标准IEEE（电气和电子工程协会） 754，任意一个二进制浮点数 V可以表示成下面的形式：
(-1)^S * M * 2^E.
(-1)^S 表示的是符号位，当 S = 0 时，V 为负数；反之 V 为正数。
M 表示有效数字， 1 <= M <= 2.
2^E 表示指数位。
举例来说：
// 十进制转2进制
5.5 -> 101.1
// 转化为
(-1)^0 * 1.011 * 2^2
// S = 0, E = 2, M = 1.011
// 十进制转2进制
-5.5 -> -101.1
// 转化为
(-1)^1 * 1.011 * 2^2
// S = 1, E = 2, M = 1.011
知道了浮点数的保存形式，那么它在内存中是如何存储的呢？
IEEE754规定：
对于32位的浮点数，最高的1位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。
而对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M。
这套规则对于 E 和 M，还有一些特殊规定：
M
由于 1 <= M <= 2，也就是说，M 可以写为 1.xxxxxx 的形式，xxxxx表示小 数位，M 的整数位默认为 1。所以计算机在存储时，只保留后面的小数部分，这样就有 23 bit 的空间存小数部分，增加精度。
E
E 是一个无符号数，如果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 ，即 0001001 。
举例来说：
int main()
{
float a = 5.5;
// 二进制：101.1
// 科学计数法：(-1)^0 * 1.011 * 2^2
// S = 0
// E = 2 + 127 = 129
// M = 1.011
// 存储到内存：
// 0100 0000 1011 0000 000000000000
// 4 0 b 0 000
// 0x40b00000
}
然后，指数E从内存中取出还可以再分成三种情况：
E不全为0或不全为1
这时，浮点数就采用下面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将有效数字M前加上第一位的1。
E全为0
这时，浮点数的指数E等于1-127（或者1-1023）即为真实值。
E全为1
这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s) 。
例题：
下面代码的输出是？
#include<stdio.h>
int main()
{
int n = 9;
// 内存中存放补码：
// 00000000 00000000 00000000 00001001
//
// 转化 float 型：
// 0 00000000 0000000000000000001001
float* pFloat = (float*)&n;
printf("n的值为：%d\n", n);// 9
printf("*pFloat的值为：%f\n", *pFloat); // 0.000000
*pFloat = 9.0;
// 直接为 float 型
// 1001.0
// (-1)^0 * 1.001 * 2^3
// S = 0, M = 1.001
// E = 3 + 127 = 130
// 0 10000010 00100000000000000000000
// 01000001000100000000000000000000
//
printf("num的值为：%d\n", n); // 109156716
printf("*pFloat的值为：%f\n", *pFloat); // 9.0
return 0;
}
好了，关于浮点数在内存中的存储就介绍到这里。
807
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
