本文详细介绍了C语言中的数据类型，包括整型、浮点型、构造型和指针类型，以及它们在内存中的存储方式。重点讨论了整数的原码、反码、补码表示，大小端字节序的概念，以及如何通过代码判断系统字节序。还探讨了浮点数在内存中的IEEE 754标准表示。
数据类型介绍
char
//
字符数据类型
short
//
短整型
int
//
整形
long int
//
长整型
long long int
//更长的整形
float
//
单精度浮点数
double
//
双精度浮点数
类型的意义
1.
使用这个类型开辟内存空间的大小（大小决定了使用范围）。
2.
如何看待内存空间的视角
类型的基本分类
整形
char（因为char存储是以ASCII值的形式存储的，ASCII是整数，所以归为整形）
unsigned char （无符号的char）
signed char （有符号的char） （以下类似）
short
unsigned short int
signed short int
int
unsigned int
signed int
long
unsigned long int
signed long int
浮点型
float
double
构造型
数组类型
结构体类型
struct
枚举类型
enum
联合类型
union
指针类型
int *pi
char *pc
float* pf
void* pv
...
空类型
void
表示空类型（无类型）
通常应用于函数的返回类型、函数的参数、指针类型
void test(void)
{
printf("这里不需要接受参数，也不需要返回，所以都是void\n");
}
int main()
{
test();
return 0;
}有了大致的介绍，我们接下来先介绍整数在内存中的存储。
整形在内存中的存储
这里我之前已经介绍过了，可以到这个里移位操作符的原码，反码，补码这里具体看一下【编程之路（008）操作符详解】（C语言实现）_p_fly的博客-优快云博客
另外需要补充一下，无符号的数可以理解为正数。
如果你已经看完了整数的存储或者你已经知道其存储方法，那么接下来我会补充为什么是这样存储的。
在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统
一处理；
同时，加法和减法也可以统一处理（
CPU
只有加法器
）此外，补码与原码相互转换，其运算过程
是相同的，不需要额外的硬件电路。
第二点简单讲一下：
原码按位取反得到反码，反码加一得到补码。
得到补码除了逆推回去之外，其实还有另一种方法。
补码按位取反加一即可得到原码。
大小端字节序
大端（存储）模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址
中；
小端（存储）模式，是指数据的低位保存在内存的低地址中，而数据的高位,，保存在内存的高地
址中
为什么会有大小端模式之分呢？这是因为在计算机系统中，我们是以字节为单位的，每个地址单元
都对应着一个字节，一个字节为
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
处理器还可以由硬件来选择是大端模式
还是小端模式。
如下图所示：
用代码如何判断大小端字符序？
#include<stdio.h>
int main()
{
int a = 1;
//1的十六进制：0x 00 00 00 01
//把a的地址取出，并且强制转换成char*类型的指针
//强制转换的意义是为了微操：具体看到每一个字节是什么值
char* pa = (char*)&a;
if (*pa == 1)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
return 0;
}总结一下：小端就是老老实实，低位存放到低地址，大端比较叛逆，与之相反。
整形的存储练习
练习之前需要了解
1.
//打印什么？
#include <stdio.h>
int main()
{
char a = -1;
//-1
//原码：10000000 00000000 00000000 00000001
//反码：11111111 11111111 11111111 11111110
//补码：11111111 11111111 11111111 11111111
//因为char类型只能放下一个字节（8个比特位），所以在内存中存储就要截断
//实际：11111111
signed char b = -1;
//vs2019下，char与signed char一样
//实际：11111111
unsigned char c = -1;
//-1
//原码：10000000 00000000 00000000 00000001
//反码：11111111 11111111 11111111 11111110
//补码：11111111 11111111 11111111 11111111
//和上面一样
//实际：11111111
printf("a = %d\nb = %d\nc = %d\n", a, b, c);
//以%d的形式打印--以整形的形式打印
//所以a，b，c都要整形提升才可以打印
//整形提升看类型，类型是有符号的类型，高位补符号位
// 类型是无符号的类型，高位补0
//整形提升：
//a：补码：11111111 11111111 11111111 11111111
// 反码：10000000 00000000 00000000 00000000
// 原码：10000000 00000000 00000000 00000001
//b：与a同理
// 原码：10000000 00000000 00000000 00000001
//c：补码：00000000 00000000 00000000 11111111
//由于c是无符号类型，可以看作正数。正数的原码，反码与补码相同
return 0;
}结果如下：
2.
#include <stdio.h>
int main()
{
char a = -128;
//补码：10000000 00000000 00000000 10000000
//实际：10000000（存的后低八位）
printf("%u\n", a);
//打印的是无符号整数
//整形提升，a是char型，有符号，高位补符号位
//补码：00000000 00000000 00000000 10000000
//反码：11111111 11111111 11111111 01111111
//原码：11111111 11111111 11111111 10000000
return 0;
}结果：
3.
#include <stdio.h>
int main()
{
char a = 128;
//因为是正数，所以补码==反码==原码：
// 00000000 00000000 00000000 10000000
//实际：10000000
printf("%u\n", a);
//整形提升，a为char型，高位补符号位
//11111111 11111111 11111111 10000000
return 0;
}结果：
4.
#include<stdio.h>
int main()
{
int i = -20;
//原码：10000000 00000000 00000000 00010100
//反码：11111111 11111111 11111111 11101011
//补码：11111111 11111111 11111111 11101100
unsigned int j = 10;
//原码==反码==补码：00000000 00000000 00000000 00001010
printf("%d\n", i + j);
//按照补码的形式进行运算，最后格式化成为有符号整数
//补码：11111111 11111111 11111111 11110110
//反码：10000000 00000000 00000000 00001001
//原码：10000000 00000000 00000000 00001010
}
//结果：-105.
#include<stdio.h>
int main()
{
unsigned int i;
for (i = 9; i >= 0; i--)
{
printf("%u\n", i);
}
return 0;
}
这里程序会陷入死循环，编译器也警告了。就跟第一题之前的那个图中的unsigned char情况一样，就算在这么减，它也还是正数。
6.
#include<stdio.h>
int main()
{
//-128~127
char a[1000];
int i;
for (i = 0; i < 1000; i++)
{
a[i] = -1 - i;
}
//-1 -2 -3 ... 0
//a[0] a[1] a[2]... a[x]
//根据上图的圆环表示，从-1到0之间有127+128=255个
printf("%d", strlen(a));
//strlen是计算字符串个数的，当找到'\0'也就是0时，会停止
return 0;
}
//结果为2557.
#include <stdio.h>
unsigned char i = 0;
int main()
{
for (i = 0; i <= 255; i++)
{
printf("hello world\n");
}
return 0;
}
//结果：死循环打印由于我们知道，unsigned char的范围是0~255，所以就会一直循环。
小结一下：当大的类型的要放到小的类型中时，这时就会发生截断（保留低位）。（主要只是有 放的动作的时候才会截断）。
当要使用被截断的小的类型要拿出来使用时，看是否可以与使用对象相对应（比如 char类型的以%d形式打印的时候，就要发生整形提升）。
整形提升要看原本的类型，原类型是有符号类型，按符号位提升，否则补0；
以上便是整数部分的内容，接下来的部分将会介绍浮点数在内存中的存储。
浮点型在内存中的存储
浮点数存储规则：
根据国际标准
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
对于
64
位的浮点数，最高的
1
位是符号位S，接着的
11
位是指数
E
，剩下的
52
位为有效数字
M
举个简单的例子：
十进制5.0==二进制101.0==1.01×2^2(这里可以类比成十进制的科学计数法)
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的规定
前面说过，
1≤M<2
，也就是说，
M
可以写成
1.xxxxxx
的形式，其中
xxxxxx
表示小数部分。
IEEE 754
规定，在计算机内部保存
M
时，默认这个数的第一位总是
1
，因此可以被舍去，只保存后面的 xxxxxx部分。
比如保存
1.01
的时 候，只保存01
，等到读取的时候，再把第一位的
1
加上去。这样做的目的，是节省
1
位有效数字。以
32
位 浮点数为例，留给M
只有
23
位， 将第一位的1
舍去以后，等于可以保存
24
位有效数字。
IEEE 754
对指数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
不全为
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
）；
希望这篇文章可以帮到你，有什么不对的也希望在评论区提出来。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
