为什么存在动态内存分配

根据我们已经掌握的内存开辟方式有：

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

但上述开辟空间的方式有两个特点：

1.空间开辟的大小是固定的
2.数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。 这时候就只能试试动态存开辟了。

动态内存函数的介绍

动态内存函数的介绍
动态内存函数的开辟是作用于堆上开辟的

malloc

c语言提供一个动态开辟的函数

引用头文件

返回值：

中文翻译：

这个函数向内存申请一块连续可以使用的空间，并且返回这个空间的起始地址
如果开辟成功，则返回一个指向开辟好空间的指针
如果开辟失败，则返回一个NULL指针
返回值的类型是void*，所以malloc函数并不知开辟空间的类型，具体使用的时候根据使用者决定
如果参数size为0，malloc的行为是未定义的，取决于编译器

malloc的例子

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
int*arr=(int*)malloc(sizeof(int)*10);
if(arr==NULL)
//perror("失败的原因:");
//printf("%s\n",strerror(errno));
}

errno 是记录系统的最后一次错误代码。代码是一个int型的值，在errno.h中定义。查看错误代码errno是调试程序的一个重要方法。
strerror 通过标准错误的标号，获得错误的描述字符串 ，将单纯的错误标号转为字符串描述，方便用户查找错误。

malloc开辟失败的例子

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
int*arr=(int*)malloc(sizeof(int)*INT_MAx);
if(arr==NULL)
//perror("失败的原因:");
//printf("%s\n",strerror(errno));
}

开辟失败的原因，INT_MAX是一个非常大的数字
malloc最大的开辟空间

free

每一次的动态内存开辟都要进行free进行释放和回收空间，把空间还给操作系统，以防止空间泄露。

void free(void* ptr);
free函数用来释放动态开辟的内存。
1.如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的
2.如果参数ptr是NULL指针，则函数什么事都不做。
3.每次free完，切记要把ptr函数置成NULL，

calloc

函数的参数
void* calloc(size_t num,size_t size);

calloc于malloc不同，calloc会开辟num个大小为size的空间，并且会把这些空间的内容初始化为0

举个例子

int main()
{
	int* p = NULL;
	p =(int*)calloc(10, sizeof(int));
	if (p == NULL)
		exit(-1);
	free(p);
	p = NULL;
}

realloc

realloc函数的出现让动态内存管理更加灵活。
有时我们申请的空间太小了，或者太大了，那么我们为了合理的利用内存，我们一定会对内存进行灵活的调整
void* realloc(void*ptr,size_t size);
其中ptr是要调整的内存地址
size为重新调整的大小
函数的返回值为内存的起始地址
realloc函数开辟失败的时候则会返回一个NULL
这个函数调整原内存空间大小的基础上，还会将原有的内存中的数据移动到新的空间，并且会释放掉原有空间。

就好比上面的两个情况，
情况1，后续空间足够大，所以relloc申请的空间会在原有空间之后直接追加空间，并且原空间的数据不会发生改变，
情况2，当后续空间的大小不足够大时，那么realloc将会寻找一个新的空间，会把原有空间的数据复制到新的空间里，并且会释放掉原有空间，函数会返回新的空间的大小

relloc函数的运用

#include<stdio.h>
#include<stdlib.h>
int main()
{
int*ptr=(int*)malloc(sizeof(int)*10);
if(ptr==NULL)
{
	printf("%s\n",strerror(errno));
	return -1;
}
//业务处理


//当ptr不够用要扩容时
ptr=realloc(ptr,sizeof(int)*100);
//当realloc前面忘了加强制转换时，程序运行时会发生隐式转换
if(ptr==NULL)
return -1；
free(ptr);
ptr=NULL;
//把ptr置成NULL，以防止发生非法访问
}

常见的动态内存错误

对NULL指针的解引用

void test()
{
	int*p=(int*)malloc(sizeof(int)*400000000);
	*p=20;//如果malloc的返回值是NULL，就是对NULL指针的解引用
	free(p);
	p=NULL;
}

修改后的

void test()
{
	int*p=(int*)malloc(sizeof(int)*400000000);
	if(p==NULL)
	return -1;
	*p=20;//如果malloc的返回值是NULL，就是对NULL指针的解引用
	free(p);
	p=NULL;
}

对开辟空间的越界访问

void test()
{
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(NULL == p)
 {
 exit(EXIT_FAILURE);
 }
 for(i=0; i<=100; i++)
 {
 *(p+i) = i;//当i是10的时候越界访问
 }
 free(p);
}

对非动态开辟内存进行free使用

void test()
{
int a=10;
int*p=&a;
free(p);
}

使用free函数释放内存的一部分

void test()
{
	int*p=(int*)malloc(sizeof(int)*100);
	p++;
	free(p);//p不在指向动态内存的起始位置
}

解决方法：可以设置一个指针储存放着这个内存的起始地址
例如：int*ptr=p;
free§;
p=NULL;

对同一块内存进行多次释放

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

解决方法：在第一个free§后把p设为NULL
所以当第二个free时，free(ptr)中，当ptr为NULL时，啥事也不会发生

对动态开辟内存忘记释放（内存泄漏）

void test()
{
	int*P=(int*)malloc(100);
	if(p!=NULL)
	{
		*p=20;
	}
}
int main()
{
test();
while(1);
}

什么是内存泄漏

内存泄漏的决解方法：
1.程序已结束，os系统自动会回收空间
2.free函数进行释放和回收空间

经典的笔试题

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;
}

本题考查的是值传递和址传递的问题，
str是一个变量，在GetMemory(str)中传递的是变量str的值，因此在函数GetMemory(char*p)里，p是对str的值进行临时拷贝
解决方法：
1.传str的地址，使用二级指针进行接收。
2.在GetMemory函数返回值p的地址，使用变量str进行接收

别忘了要使用free进行内存的释放，以防止内存泄漏

char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

结果如下：
这里的考察的是函数的栈帧知识：GetMemory函数调用完以后在栈区开辟的p数组的内存就已经被释放了，因此str会非法访问内存。
解决方法：加个static在char p[]前面，记得调用完要free进行释放
函数栈帧的创建与销毁
函数栈帧的调用

void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}
int main()
{
	Test();
	return 0;
}

由于free(str)释放以后str并没有将str进行置空，strcpy(str,“worlf”);会进行非法的内存访问

柔性数组

什么是柔性数组

在C99中,结构中的最后一个允许是未知大小的数组。
例如

typedef struct st_type
{
 int i;
 int a[0];//柔性数组成员
}type_a;

在有一些编译器下会报错无法编译可以改为：

typedef struct st_type
{
 int i;
 int a[];//柔性数组成员
}type_a;

柔性数组的特点

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

检测特点2：

typdef struct st_type
{
	int i;
	int a[];
}type_a;
printf("%d\n",sizeof(type_a));//4

柔性数组的使用：

typdef struct st_type
{
	int i;
	int a[];
}type_a;
int main()
{
	int i=0;
	type_a *p=(type*a)malloc(sizeof(type_a)+100*sizeof*(int));
	p->i=100;
	for(i=0;i<100;i++)
	{
	p->a[i]=i;
	}
	return 0;
}

柔性数组的优势

typedef struct st_type
{
	int i;
	int* p_a;
}type_a;
int main() {
	type_a* p = malloc(sizeof(type_a));
	p->i = 100;
	p->p_a = (int*)malloc(p->i * sizeof(int));
	//业务处理
	int i = 0;
	for (i = 0; i < 100; i++)
	{
		p->p_a[i] = i;
	}
	//释放空间
	free(p->p_a);
	p->p_a = NULL;
	free(p);
	p = NULL;
	return 0;
}

柔性数组相比于用指针的形式，其优势：

用指针的形式会做二次内存开辟，在释放时结构体的成员也必须free掉并且置为空指针。而柔性数组只需要释放一次
柔性数组由于只内存开辟一次，因此内存是连续的，访问速度也比较快。
如若有误，望指点出来。