动态分配内存深入理解

动态内存函数的介绍

1. malloc
2. free
3. calloc
4. realloc

为什么存在动态内存分配呢

	int val = 20; 在栈空间上开辟四个字节
	char arr[10] ={0};  在栈空间上开辟10个字节的连续空间

	但是上述的开辟空间的方式有两个特点：
	1.空间开辟大小是固定的。
	2.数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。
但是对于空间的需求，不仅仅是上述的情况，有时候我们需要的空间大小在程序运行的时候才能知道，
那数组的编译时开辟空间的方式就不能满足了，这时候j就只能试试动态内存开辟了

动态内存函数的介绍

malloc

malloc开辟空间 free释放空间
c语言提供了一个动态内存开辟的函数
void* malloc(size_t size);
这个函数向内存申请了一块连续可用的空间，并返回指向这块空间的指针。
1.如果开辟成功，则返回一个指向开辟好空间的指针
2.如果开辟失败，则返回一个null指针，因此malloc的返回值一定要做检查
3.返回值的类型是void*，所以malloc函数并不知道，开辟空间的类型，具体在使用的时候，使用者自己决定
4.如果参数size为0，mallocd的行为是标准是未定义的取决于编译器

free

c语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下
void free(void* ptr);
free函数用来释放动态开辟的内存
1.如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的。
2.如果参数ptr是NULL指针，则函数什么事都不做
malloc和free都声明在stdlib.h头文件中，

calloc

c语言还提供了一个函数叫calloc,calloc函数也用来d动态内存分配，
void* calloc(size_t num,size_t size);
1.函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0
2.与函数malloc的区别只在于malloc会在返回地址之前把申请的空间的每个字节初始化为全0

realloc

所以如何我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloch函数来完成任务
realloc
1.realloc函数的出现让动态内存管理更加灵活
2.有时候我们发现过去申请的空间小了，有时候我们又会觉得申请的空间过大了，那位了合理的时候内存，
我们一定会对内存的大小做灵活的调整，那realloc函数就可以做到对动态开辟内存大小的调整，函数如下
void* realloc(void* ptr,size_t size);
ptr是要调整的内存地址
size调整之后新大小
返回值为调整之后的内存起始位置
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间
realloc在调整内存空间的是存在两种情况
情况1:原有空间之后有足够大的空间
情况2：原有空间之后没有足够大的空间

malloc用法

int main()
{
	//向内存申请10个整形的空间
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
	}
	else
	{
		//正常使用空间
		int i = 0;
		for (i = 0; i < 10;i++)
		{
			*(p + i) = i; 
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p+i));	 
		}
	}
	当动态申请的空间不再使用的时候，就应该还给操作系统
	free(p);
	p = NULL;
	这里的意思就是关系断了电话号码还在，
	所以要把电话号码自由掉,让你忘掉这个号码
	return 0;
}

calloc的用法

int main()
{
	//malloc(10*sizeof(int));这里是算出总大小
	int* p = (int*)calloc(10, sizeof(int));
	//这里是算出几个元素，然后每个元素的大小
	//calloc会把元素初始化为0 malloc不会初始化
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));//把错误码，所对应的信息打出来
	}
	else
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	//释放空间
	//free函数是用来释放动态开辟的空间的
	free(p);
	p = NULL;
	return 0;
}

realloc

realloc 调整动态开辟内存空间的大小
int main()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
	}
	else
	{
		int i = 0;
		for (i = 0; i < 5; i++)
		{
			*(p + i) = i;
		}
	}
	就是在使用malloc开辟的20个字节的空间
	假设这里20个字节不能满足我们的使用
	希望我们能够有40个字节的空间
	这里就可以使用realloc来调整动态开辟的内存	

	realloc使用的注意事项：
	1.如果p指向的空间之后有足够的内存空间可以追加，则直接追加，后返回p
	2.如果p指向的空间之后没有足够的内存空间可以追加，则realloc函数会重新找一个新的内存区域
	开辟一块满足需求的空间，并且把原来内存中的数据拷贝回来，释放旧的内存空间,最后
	返回新开辟的内存空间地址
	3.得用一个新的变量来接收realloc函数的返回值
	int* ptr = realloc(p,INT_MAX);
	if (ptr != NULL)
	{
		p = ptr;
		int i = 0;
		for (i = 5; i < 10; i++)
		{
			*(p + i) = i;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	//释放内存
	free(p);
	p = NULL;		
	return 0;
}

常见的动态内存错误

第一个错误，对NULL指针的解引用操作

int main()
{
	int *p = (int*)malloc(40);
	//万一malloc失败了，p就被赋值为NULL
	//所以一定要进行判断
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
	}
	else
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;
		}
	}
	free(p);
	p = NULL;
	return 0;
}

第二个错误

对动态开辟内存的越界访问

int main()
{
	int *p = (int*)malloc(5 * sizeof(int));//这里之开辟了5个整型元素
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
	}
	else
	{
		int i = 0;
		for (i = 0; i < 10; i++)//这里访问了10个元素，所以越界访问
		{
			*(p + i) = i;
		}
	}
	free(p);
	p = NULL;
	return 0;
}

第三个错误，乱用free free是堆区里面的

int main()
{
	int a = 10;
	int* p = &a;
	*p = 20;
	//对非动态开辟内存的使用free释放
	free(p);
	p = NULL;
	return 0;
}

第四个错误

使用free释放动态开辟内存的一部分

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 0;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p++ = i;
	}
	//回收空间
	free(p);//p不再指向动态内存的起始位置
这里的错误就是p释放的是后面的空间而不是开始位置的空间
	p = NULL;
	return 0;
}

第五个错误

对同一块动态内存多次释放

void test()
{
	int *p = (int *)malloc(100);
	free(p);
	free(p);//重复释放 
}

第六个错误，动态开辟内存忘记释放（内存泄露）

int main()
{
	while (1)
	{
		malloc(1);//这里没有用free进行内存释放
	}
	return 0;
}
忘记释放不再使用的动态开辟的空间会造成内存泄漏，切记动态开辟的空间一定要释放
并且一定要正确的释放

几道经典的笔试题

请问运行Test函数会有什么样的结果

void GetMemory(char* p)
{
	p = (char *)malloc(100);
}
void Test(void)
{
	char *str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
这里程序会出现崩溃，因为访问内存失败，
因为str并没有指向有效空间，
	
	失败原因：
	1.运行代码程序会出现崩溃的现象
	2.程序存在内存泄露的问题
	str以值传递的形式给p
	p是GetMemory函数的形参，只能函数内部有效，等GetMemory函数返回之后，动态开辟内存尚未释放，
	并且无法找到，所以会造成内存泄露
	
	printf(str);
}
int main()
{
	Test();
	return 0;
}

将上面的代码改进变成正确的代码

改进方法1
void GetMemory(char** p)
{
	*p = (char *)malloc(100);
}
void Test(void)
{
	char *str = NULL;
	GetMemory(&str);
	strcpy(str, "hello world");
	printf(str);
}
int main()
{
	Test();
	return 0;
}
改进方法二
char* GetMemory(char* p)
{
	p = (char *)malloc(100);
	return p;
}
void Test(void)
{
	char *str = NULL;
	str = GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

test函数执行的时候会输出什么

结构就是随机值

char* GetMemory(void)
{
	char p[] = "hello world";
	//这里是局部变量，只在这个函数内部有效，它的生命周期就是进入它的范围生命周期开始，出它的范围，
	//生命周期结束,当出去时确实把地址返回去了，但是这个空间还给操作系统了，这个空间里面的值接下来
	//是什么就是系统随机了
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

面试模拟题 返回栈空间的问题

int* test()
{
	//static int a = 10;静态区
	int a = 10;//栈区
//栈区  这里给前面加上一个static就可以了
//因为static修饰局部变量，局部变量生命周期变长,a除了范围不销毁还在
	return &a;
}
int main()
{
	int* p = test();
	*p = 20;
	return 0;
}

int* test()
{
	int * ptr = malloc(100);//堆区  堆空间只有free才能回收，所以这里也是可以的
	return ptr;
}
int main()
{
	int* p = test();
	return 0;
}

面试题请问运行Test函数会有什么样的结果

void GetMemory(char **p, int num)
{
	*p = (char *)malloc(num);
}
void Test(void)
{
	char *str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
	free(str);
	str = NULL;
	//这里打印结果是hello
/*
忘记释放动态开辟的的内存，导致内存泄露了 要用free释放	
*/
}
int main()
{
	Test();
	return 0;
}

void Test(void)
{
	char *str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
//free释放str指向的空间后，并不会把str置为null,所以要自己加上str = null，free释放完置为空
	if (str != NULL)
	{
		strcpy(str, "world");
		//非法访问内存 你都已经把它释放了，但还是要访问它
		printf(str);
	}
}
int main()
{
	Test();
	return 0;
}

c/c++程序内存分配的几个区域

1.栈区：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些
存储单元自动被释放，栈内存分配运算内置于处理器的指令集中，效率很高但是分配的内存容量有
限，栈区主要存放运行函数而分配的局部变量函数参数，返回数据，返回地址等
2.堆区：一般由程序员分配释放，若程序员不释放，程序结束时可能有OS回收，分配方式类似于链表
3.数据段（静态区）（static）存放全局变量，静态数据，程序结束后由系统释放
4.代码段：存放函数体（类成员函数和全局函数）的二进制d代码

实际上普通的局部变量是在栈区分配k空间的，栈区的特点是在上面创建的变量出了作用域就销毁
但是被static修饰的变量存放在数据段(静态区)，数据段的特点是在上面创建的变量，直到程序结束才销毁
所以生命周期变长

柔性数组

C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做[柔性数组]成员
这两种方法都可以，如果第一种方法编译器编译不过去，那么就用第二种方法

第一种方法(1)如果编译器运行不了就用下面哪种
struct S
{
	int n;
	int arr[];	//结构体中最后一个元素是未知大小的
	未知的大小的-柔性数组成员 -数组的大小是可以调整的
};
(2)
struct S
{
	int n;
	int arr[0];	//结构体中最后一个元素是未知大小的
未知的大小的-柔性数组成员 -数组的大小是可以调整的

柔性数组的具体使用

struct S
{
	int n;
	int arr[0];//未知大小的-柔性数组成员-数组的大小是可以调整的
};
int main()
{													  //这里就是对柔性数组进行空间创建
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 5*sizeof(int));
	ps->n = 100; //100
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		ps->arr[i] = i; // 0 1 2 3 4
	}
	struct S* ptr = realloc(ps, 44);//进行调整对柔性数组进行调整变多点	
	if (ptr != NULL)
	{
		ps = ptr;
	}
	for (i = 5; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 10; i++)//这里进行打印
	{
		printf("%d ", ps->arr[i]);
	}
	//释放空间
	free(ps);
	ps = NULL;
	return 0;
}

其他的方法

struct S
{
	int n;
	int* arr;
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	ps->arr = malloc(5 * sizeof(int));
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 5; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	//调整大小
	int * ptr = realloc(ps->arr,10*(sizeof(int)));
	if (ptr != NULL)
	{
		ps->arr = ptr;
	}
	for (i = 5; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	//释放内存
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;
	return 0;
}

经过两次方便比较，还是柔性数组更好一些,malloc free用的少，错误概率比较少
第二个方法错误率比较高,malloc用的越多越频繁，内存碎片越多,内存利用率低

柔性数组的特点

1. 结构中的柔性数组成员前面必须至少一个其他成员
2. .sizeof返回的这种结构大小不包括柔性数组的内存
3. 包含柔性数组成员的结构用malloc()函数进行内存的动态分配,并且分配的内存应该大于结构的大小，
   以适应柔性数组的预期大小

柔性数组的优点

1.方便内存释放做一次free就可以把所有的内存也给释放掉
2.这样有利于访问速度

最后介绍一位大神和它的座右铭

陈皓