数据在内存中的存储

首先来看一下数据类型的介绍

• 内置类型

char
short
int 
long
float
double

•  类型的归类

整形：
char
unsigned char
signed char
short
    unsigned short
    signed short
int
    unsigned int 
    signed int 
long
    unsigned long
    signed long

• 构造类型

数组类型
结构体类型 struct
枚举类型 enum
联合类型 union

•  数组类型

//数组类型为什么是构造类型的，这里看一个代码就明白了
#include <stdio.h>

 int main()
 {
 	int arr[10];
 	printf("%d\n", sizeof(arr));//40
 	printf("%d\n", sizeof(int[10]));//40
 }
//在这里数组类型就是 int[10]

• 指针类型
• 空类型

void表示空类型（无类型）
通常用于函数的返回类型、函数的参数、指针类型

---

整形在内存中的存储

在这之前先来了解一下原码、补码、反码的概念

这三种表示方法都是计算机中符号数的表示方法，均有符号位和数值位两部分 数值位三种表示方法各不相同

符号位："0" 表示正,"1"表示负

•  原码：直接将二进制按照正负数的形势翻译成二进制
•  反码：原码的符号位不变，其他位按位取反
•  补码：反码+1

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

对于整数：数据存放在内存中其实存放的是补码

下面给大家看一下整数在内存中的存储

#include <stdio.h>

int main()
{
    int a = 20;
    //00000000 00000000 00000000 00010100
    //00 00 00 14  (16进制)
    //正数的原反补相同
    int b = -10;
    //10000000 00000000 00000000 00001010(原码)
    //11111111 11111111 11111111 11110110(反码+1)
    //ff ff ff f6
    return 0;
}

在计算机中它的内存是这样存储的

在这里我们看到内存中的存储和我们想的不太一样，这里呢要给大家介绍一下大小端的知识

•  大端(大端字节序)：数据的低位保存在内存的高地址中，高位保存在内存的低地址中
•  小端(小端字节序)：数据的低位保存在内存的低地址中，高位保存在内存的高地址中

我们来写一个程序看看如何判断当前机器的字节序

#include <stdio.h>

int check_sys()
{
	int i = 1; //我们以1来判断大端还是小端,用char*类型只提取一个字节
	//00000000 00000000 00000000 00000001 
	//化成16进制(只比较第一位，若为0则为大端，1则为小端)
	//00 00 00 01 (大端)
	//01 00 00 00 (小端)
	return (*(char *)&i);
}

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

浮点型在内存中的存储

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

根据国标IEEE 754，任意一个二进制浮点数可以表示成

(-1)^s*M*2^E(−1)​s​​∗M∗2​E​​

• (−1)^s表示符号位，当s=0为正数，s=1为负数
• M表示有效数字，大于等于1小于2
• 2^E表示指数位

若为5.5(101.1)
则表示为(-1)^0*1.011*2^2

浮点数在内存中是如何存储的呢

IEEE 754规定：对于32位的浮点数，最高的1位是符号位，接下来的8位是指数E，剩下的23位是有效数字M

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

---

---

•  M

IEEE 754规定，在计算机内部保存M时，默认第一位总是1，因此可以省去只保存后面部分，取出来时再将1补回去。比如1.01，只保存01，这样就可以多一位有效数字，使精度更准确。

•  指数E

E为一个无符号整数，8位中（0——255），11位中（0——2047）

当E为负数的时候在IEEE 754中规定，存入内存中的E必须在加上一个中间数，对于8位中间数为127，对于11位，中间数为1023

例如2^10中E=10，所以保存为32位浮点数时必须为10+127=137，化为二进制 1000 1001

E分三种情况：

1.不全为0或者不全为1：正常处理

2.E全为0：这时浮点数的指数E=1-127=-126，而2^-126这个值很小，接近于0，所以全为0时表示+0/-0

3.E全为1：这是如果有效数字M全为0，表示无穷大（正负取决于符号位S）

---

没懂？通过一道例题来深度认识一下：

#include <stdio.h>

 int main()
 {
 	int n = 9;
 	float *pFloat = (float *)&n;
 	//0 00000000 00000000000000000001001 (9.0在内存中的存储)
 	//(-1)^0*0.00000000000000000001001*2^-126 (转化为IEEE 754规定形式)
 	
 	printf("n的值为：%d\n",n);//9
 	printf("*pFloat的值为：%f\n",*pFloat);//0.000000
 
 	*pFloat = 9.0;
 	//1001.0 (9.0的二进制形式)
 	//1.001*2^3
 	//0 10000010 00100000000000000000000
 	//num为正数，它的原反补相同
 	printf("num的值为：%d\n",n);//1091567616
 	printf("*pFloat的值为：%f\n",*pFloat);//9.0
 	return 0;
 }

C/C++程序内存的分配

内存分配方式有三种：

•  在静态区分配

内存在程序编译的时候就已经分配好，在整个运行期间都存在

•  在栈上创建

执行函数时，函数局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。

•  从堆上分配

程序员运行的时候使用malloc/new申请任意多少的内存，程序员自己负责在何时用free/delete释放内存。

动态内存的生存期有程序员决定，使用非常灵活，但如果在堆上分配了空间，就有责任收回他，否则在运行时会出现内存泄漏。

频繁的分配和释放不同大小的堆空间将会产生堆内存碎块。

我们来看一段代码，对上述内容进一步的了解

#include <stdio.h>

void test()
{
	printf("hehe\n");
}
int g_val = 0;
int main()
{
	int a = 10;
	int b = 20;

	static int c = 0;

	char *p1 = (char *)malloc(10);
	char *p2 = "abcdef";

	return 0;
}