学习目标：

学习数据在内存中的存储：

学习内容：

1、数据类型

1.1

char? //字符数据类型? ? ?1字节

int? ? ///整型数据类型? ? ? 4个字节

short? ?//短整型? ? ? ? ? ? ? ? 2字节

long int? //长整型? ? ? ? ? ? ? ? >=4字节

long long int? //更长的整型? ? ? ? 8字节

float? ? //单精度浮点数? ? ? ? 4字节

double? ? ?//双精度浮点数? ? ? ? 8字节?

数据类型决定了开辟内存的大小；

整型中：

unsigned int? ? ?//无符号的int? ? ? 有些数据是没有负数的

char? ? ?signed char? ? //有时默认两者是一样的

unsinged char? ? ? ?//char也是整型

long? int

long long int

浮点数：

float

double

自定义类型：

数组? ?

结构体? ?struct

枚举? ? ? ? ? ?enum

联合? ? ? ? ? union

指针类型：

char*? p1? ? ? 字符指针

int*? ? p2? ? ?整型指针

float*? ? pf? ? ? ?单精度指针

double*? pf2? ?双精度指针

空类型：

void

主要用于函数的返回值，函数的参数，以及指针

2.整型在内存中的存储

int? a =10;

int b = -10;

a,b在内存中是以二进制存储的,且存放的是整型的补码

一个整型4字节32比特位

        int a = 10;
		int b = -10;
		//00000000000000000000000000001010    原码
		//00000000000000000000000000001010    反码
		//00000000000000000000000000001010    补码
		//正数的  原 反 补 是相同的

		//10000000000000000000000000001010    原码
		//11111111111111111111111111110101    反码
		//11111111111111111111111111111010	  补码
		//负数在内存中是以补码的方式存储的
		//原符号位不变，其他位按位取反得到反码
		//反码+1  得到补码

原码和补码之间的转换：

3.大小端字节序

当我们把ox11223344这样一个16进制数存在内存中时可以顺序，也可以逆序

? ? ? ? ? 11 22 33 44? ? ? ? ? ? ? ? ? ? ? ? 也可? 44 33 22 11?

? ? ? ? ??高?<——低

两种存放方式

介绍以及判断

?一个小试题：

? ? ? ? ? ? ? ?设计一个小程序来判断当前机器的字节序。?

void pd(int a)
{
?? ?if (1==(*(char*)&a))? ? ? ? ? ? ? ?
?? ?{
?? ??? ?printf("小端\n");
?? ?}
?? ?else
?? ??? ?printf("大端\n");
}
int main()
{
?? ?int a = 1;
?? ?pd(a);

?? ?return 0;
}

解析：

1的二进制

00000000000000000000000000000001

我们取出1的地址只用判断一位，因此强制转换为（char*)使他指向一个二进制位，正在解引用找到最低地址存放的数字?

如果是小端，则最低位存放的是1

如果是大端，则最低位存放的是0

4.浮点数在内存中的存储解析

先看一例子：

我们可以发现，同一个数存储为不同类型时，输出的大小不一样。

浮点数的存储方式：

?????????(-1)^S * M * 2^E

其中S是0或者1，0是正数，1是负数

M表示有效数字，大于0小于1的数

E表示指数位

比如十进制的5.0写成二进制位? 101.0 也即是? 1.01

其中按照：（-1)^0*1.01*2^2

S==0；M ==1.01；E==2

在内存中是这样存储的

?

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

IEEE 754规定

因为M总是1开头，所以存储时是省去了的、只需要存? .0101?,取出时在加上1

这样可以让有效数字多一个存储空间

i

E是非负的，因此防止出现负数

float存时加上127

doubl存储时加上1023

如? 2^10? E为10，存储时加上127，实际存的是137；

将存进去的数取出来：

当E不全为0和不全为1时

比如00.5的二进制为? ?0.1? 也就是? 1.0*2^(-1)??

S==0；M==1.0；E== -1；

E=E+127? ——> E=126；

0? 01111110 0000000000000

当E 全为0时

E= -127

2^（-127）接近于0

当E 全为1时

E=2^128? 是一个很大的数

现在来解释前面的例题

n=9.0；

强制转换为float型时

00000000000000000000000000001001? 原本是这样存的

取出来时

S=0;E=? -126;M=0.0000000000000000000000001001

M*2^(-126)接近于0

9.0是1001.0也即是1.001

存在内存中是

0 10000010?00100000000000000000000

转化为整型后

就是

0 10000010?00100000000000000000000

也就是

1091567616