文章目录
为什么存在动态内存分配
根据我们已经掌握的内存开辟方式有：
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掉并且置为空指针。而柔性数组只需要释放一次
柔性数组由于只内存开辟一次，因此内存是连续的，访问速度也比较快。
如若有误，望指点出来。