动态内存管理
栈区:局部变量,函数的形式参数
堆区:动态内存分配malloc/free,calloc,realloc
静态区:全局变量,静态变量
malloc
void* malloc(size_t size);
-
如果开辟成功,则返回一个指向开辟好空间的指针
-
如果开辟失败,返回一个NULL指针,因此malloc的返回值一定要做检查
-
返回的类型是void*,所有malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自己来决定
-
如果参数size为0,malloc的行为是标准是未定义的,取决于编译器
free
void free(void* ptr);
- 如果参数ptr指向的空间不是动态开辟的,那free函数的行为是未定义的
- 如果参数ptr是NULL指针,则函数什么事都不做。
#include<stdio.h>
#include<stdlib.h>
int main()
{
//int arr[10];//40个字节
//char arr2[40];//40个字节
//申请空间
int* p = malloc(40); // 如果申请太大,会失败
int* ptr = p;
if (p==NULL)
{
perror("malloc");
return 1;
}
for(int i = 0;i<10;i++)
{
*(ptr+i) = i;
}
//释放空间
//free(p);//err 参数为起始地址
free(ptr);
ptr = NULL; //用完后要变成空指针
/*
if (ptr != NULL)
{
*ptr = 100;
}
*/
return 0;
}
//如果不释放动态申请的内存的时候
//程序结束,动态申请的内存由操作系统自动回收
//但是如果程序不结束,动态内存是不会自动回收的,就会形成内存泄漏的问题
calloc
void* calloc (size_t num, size_t size);
- 函数的功能是为num个大小为size的元素开辟一块空间,并且把空间的每个字节初始化为0
int main()
{
int* p =(int*)malloc(40); // *p 都是随机值
int* p = (int*)calloc(10,sizeof(int));//calloc申请的空间会被初始化为0
if (p == NULL)
{
perror("calloc");
return 1;
}
for(int i = 0;i<10;i++)
{
printf("%d ",*(p+i));
}
free(p);
p = NULL;
}
realloc
void* realloc(void* memblock,size_t size)
- ptr 是要调整的内存地址
- size调整之后新大小
- 返回值为调整之后的内存起始位置
- 这个函数调整原内存空间大小的基础上,还会将原来内存中的数据移动到新的空间
int main()
{
int* p = (int*)malloc(40);
if(p == NULL)
{
perror("malloc");
return 1;
}
for (int i = 0;i<10;i++)
{
*(p+i) = i;
}
//空间不够,希望能放20个元素,考虑扩容
//realloc(p,80); // 把p这个空间扩容成80个字节
//如果原来位置的后面空间不够用,重新开辟空间,并数据移植,把原空间释放掉
//如果原来位置的后面空间够用,直接开辟,扩容
//p = realooc(p,80); err ,万一扩容失败,返回空指针
int * ptr = (int*) realloc(p,80);
if (ptr !=NULL)
{
p = ptr;
}
//开辟成功开始使用
free(p);
p = NULL;
return 0;
}
常见的动态内存错误
对NULL指针的解引用操作
int main()
{
int* p = (int*)malloc(1000);
int i = 0;
for (i = 0;i<250;i++)
{
*(p+i) = i; //error直接这样会警告,防止NULL空间开辟失败
}
}
对动态开辟空间的越界访问
对动态内存的边界要检查
int main()
{
int* p = (int*)malloc(100);
int i = 0;
for (i = 0;i<=25;i++)
{
*(p+i) = i; //error 循环26次,多循环一次
}
}
对非动态开辟内存使用free释放
int main()
{
int a = 10;
int* p = &a;
//...
free(p);//error a是局部变量不能够用free释放
p = NULL;
return 0;
}
使用free释放一块动态内存的一部分
int main()
{
int* p = (int*)malloc(100);
if(p == NULL)
{
return 1;
}
int i = 0;
for(i = 0;i<10;i++)
{
*p == i;
p++;
}
free(p);//error 会报错必须是起始位置
p=NULL;
return 0;
}
对同一块动态内存多次释放
int main()
{
int* p = (int*)malloc(100);
if(p == NULL)
{
return 1;
}
free(p);
p = NULL;
//...
free(p); //err 重复释放
}
动态开辟内存忘记释放
void test()
{
int* p = malloc(100);
//使用
}//出了test,p失效,内存就一直占用
int main()
{
test();
//...
while(1)
{
;
}
return 0;
}
题目
void GetMemory(char *p)// p是str的临时拷贝,没有传地址
{
p = (char *)malloc(100); //内存泄漏了
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");//对NULL的解引用操作,程序崩溃
printf(str);
}
int main()
{
test();
return 0;
}
//直接挂掉,没有结果
修改后
void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str);
strcpy(str, "hello world");//对NULL的解引用操作,程序崩溃
printf(str);
}
int main()
{
test();
return 0;
}
char *GetMemory(void)
{
char p[] = "hello world"; // hello world 出函数被销毁了
return p;
}
//返回栈空间地址的问题
void Test(void)
{
char *str = NULL;
str = GetMemory();//str是野指针
printf(str);
}
int main()
{
Test();
return 0;
}
test()
{
int a =10;
return &a;
}
int main()
{
int* p = test();
printf("%d\n",*p);//10 栈帧被覆盖
printf("%d\n",*p);//就会错误
return 0;
}
//打印出来也是错的
void GetMemory(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello"); // 可以打印,但没有free
printf(str);
//忘记释放
//free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, "hello");
free(str); // 野指针
//str = NULL;
if(str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
int main()
{
Test();
return 0;
}
柔性数组
C99中,结构最后一个元素允许是位置大小的数组,这就叫做"柔性数组"成员
typedef struct st_type
{
int i ;
int a[0];//柔性数组成员
}type_a;
typedef struct st_type
{
int i ;
int a[];//柔性数组成员
}type_a;
- 结构中的柔性数组成员前面必须至少一个其他成员。
- sizeof 返回的这种结构大小不包括柔性数组的内存。
- 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小。
柔性数组的使用
struct s3
{
int num;//4
int arr[];//柔性数组成员
};
int main()
{
struct s3* ps = (struct s3*)malloc(sizeof(struct s3)+40);
if (ps == NULL)
{
perror("realloc\n");
return 1;
}
// 4个字节给了num,40个给了柔性数组
ps->num = 100;
int i = 0;
for(i = 0;i<10;i++)
{
ps->arr[i] = i;
}
//扩容
struct s3* ptr = (struct s3*)realloc(ps,sizeof(struct s3)+80);
if (ptr == NULL)
{
perror("realloc\n");
return 1;
}
else
{
ps = ptr;
}
// 使用
free(ps);
ps = NULL;
}
struct s4
{
int num;
int* arr;
}
int main()
{
struct s4* ps = (struct s4*)malloc(sizeof(struct s4));
if(ps == NULL)
{
return 1;
}
ps-> arr = (int*)malloc(40);
if(ps->arr == NULL)
{
free(ps);
ps = NULL;
return 1;
}
//使用
return 0;
}
柔性数组的优势
- 方便内存释放
- 有利于访问速度