动态内存管理
考虑到数组不能定死,因此需要动态开辟空间。
为什么存在动态内存分配
int val=20;
char arr[10]={0};
- 空间开辟大小是固定的
- 数组在申明的时候,必须指定数组的长度,它所需要的内存在编译时分配
栈区:局部变量,函数形参
堆区:malloc,calloc,free,realloc
静态区(数据段):全局变量,静态变量
动态内存函数的介绍
1.malloc和free
void* malloc(size_t size);
malloc这个函数向内存申请一块连续可用的空间,并返回指向这块空间的指针。
- 如果开辟成功,则返回一个指向开辟好空间的指针。
- 如果开辟失败,则返回一个NULL指针,因此malloc的返回值一定要做检查。
- 返回值的类型是 void* ,所以malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自 己来决定。
- 如果参数 size 为0,malloc的行为是标准是未定义的,取决于编译器。
int main()
{
//假设开辟10个整型的空间 --10*sizeof(int)
int* p=(int*)malloc(10*sizeof(int));
if(p==NULL)
{
perror("main");///main:xxxx
return 0;
}
//使用
int i=0;
for(int i=0;i<10;i++)
{
*(p+i)=i;
}
for(int i=0;i<10;i++)
{
printf("%d\n",p[i]);
}
free(p);///回收空间,p指针不会被默认为空指针。
p=NULL;//重要!!自己动手把指针置为NULL
return 0;
}
free 用来释放动态开辟的内存
-
如果参数ptr指向的空间不是动态开辟的,则free函数的行为是未定义的。
-
int main() { int a=10; int *p=&a; free(p);//!! }
-
-
如果ptr是NULL指针,则函数什么事都不做。
2.calloc
开辟一块空间并且初始化为0.
void* calloc(size_t num,size_t size)
{
}
//num---需要元素的个数
//一个元素的大小
3.realloc
- realloc的出现让动态内存管理更加灵活
- 有时我们会发现过去申请的空间太小了,有时候我们又觉得申请的空间过大了,那为了合理的适合内存,我们一定会对内存大小做灵活的调整
- realloc在调整空间时
- 弥补后两块合起来在当前堆空间里没有其他碰撞
- 连接上去,指针指向的地址不变。
- 在第二块拼接到前面的时候和堆空间里其他内存块碰撞了
- 重新找一块空间,把原先空间的内
- 容拷贝下来,再返回新地址。
- 原来的那一块空间还给操作系统。
- 找不到合适的空间调整大小
- 返回空指针
- 因此realloc后不要把原来的p指针被赋值修改。
- 弥补后两块合起来在当前堆空间里没有其他碰撞
- 单独使用realloc的时候也能实现malloc的效果
void* realloc(void* memblocks,size_t size);
memblock---前面开辟的内存空间起始地址
size--新的大小
int main()
{
int* p=(int*)malloc(10*sizeof(int));
if(p==NULL)
{
perror("main");
return 1;
}
int i=0;
for(int i=0;i<10;i++)
{
*(p+i)=5;
}
//还需要5个,这里需要p指向的空间更大,需要20个int空间
//realloc 调整空间
realloc(p,20*sizeof(int));///新的大小
///返回重新调整后的内存块指针
//p=realloc(p,20*sizeof(int));///!!! 可能偷鸡不成蚀把米
//拿临时指针
int* ptr=realloc(p,20*sizeof(int));
if(ptr!=NULL) p=ptr;
free(p);
p=NULL;
return 0;
}
int main()
{
int* p=(int*)realloc(NULL,40);//这里功能类似malloc
}
常见的动态内存错误
1.对NULL指针的解引用操作
- 对malloc函数的返回值做判空处理
int main()
{
int *p=(int*)malloc(1000000000*sizeof(int));
//if(p==NULL)
for(int i=0;i<10;i++)
{
*(p+i)=i;///非法访问内存
}
return 0;
}
2.对动态开辟的空间进行越界内存访问
int main()
{
int* p=(int*)malloc(10*sizeof(int));
if(p==NULL)
{
return 1;
}
int i=0;
for(i=0;i<40;i++)
{
*(p+i)=i;
}
free(p);
return 0;
}
3.对非动态开辟空间使用free
int main()
{
int arr[10]={0};
int* p=arr;
//使用
free(p);//对非动态开辟空间使用free
p=NULL;
}
4.用free释放动态开辟内存的一部分
- 内存泄漏
int main()
{
int *p=malloc(10*sizeof(int));
if(p!=NULL) return 1;
for(int i=0;i<5;i++)
{
*p++=i;
}
free(p);
p=NULL;
}
5.对同一块动态开辟的内存多次释放
- 所以防止这种情况一旦释放完养成置为NULL指针就不会产生这种问题
int main()
{
int* p=(int*)malloc(100);
//使用
//释放
free(p);
//释放
free(p);
return 0;
}
6.动态开辟的空间忘记释放
void test
{
int* p=(int*)malloc(100);
if(p==NULL)
{
return;
}
//使用
}
int main()
{
test();
//...
return 0;
}
练习题
void GetMemory(char *p)
{
p = (char *)malloc(100);
}
//改:
char* GetMemory(char *p)
{
p = (char *)malloc(100);
return p;
}
//改:
void GetMemory(char** p)
{
*p = (char *)malloc(100);
}
GetMemory(&str);
void Test(void)
{
char *str = NULL;
str=GetMemory(str);
strcpy(str, "hello world");
printf(str);//?ok
printf("hello world");//本质是传过去h的地址
free(str);
}
-
值传递
-
p指针malloc后指向申请的空间
-
但是str仍然是NULL
-
归类维为:返回栈空间地址的问题
- 上题是堆
char *GetMemory(void)
{
char p[] = "hello world";
return p;//char* tmp=p; return tmp;
}
void Test(void)
{
char *str = NULL;
str = GetMemory(); ///这里就要开始认为,结束栈帧后里面的东西就给“销毁了”。出现这种情况一律认为不行
printf(str);
}
int main()
{
Test();
}
-
野指针问题
- 指针声明的时候要初始化
-
没有free
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);
}
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, "hello");
free(str);
if(str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
///提前free.
总的来说
- 栈空间和堆空间的内存开辟
- 野指针问题
- free问题
- malloc必定要有free
- free后必定要置空
c++中程序内存空间分布
- 内核空间(栈区)
- 用户代码不能读写
- 栈 (栈区)
- 向下增长
- 内存映射段(堆区)
- 文件映射
- 动态库
- 匿名映射
- 堆(堆区)
- 向上增长
- 数据段(静态区)
- 全局数据
- 静态数据
- 代码段(静态区)
- 可执行代码
- const常量
对开始讲到的static修饰局部变量:
实际上普通的局部变量是在栈区分配空间的,栈区的特点是在上面创建的变量出了作用域就
销毁。
但是被static修饰的变量存放在数据段(静态区),数据段的特点是在上面创建的变量,直到程序结束才销毁。
所以生命周期变长。
柔性数组
C99中,结构中的最后一个元素允许是未知大小的数组,这个称为[柔性数组]成员。
struct S
{
int n;
int arr[];//大小是未知的
};
struct S
{
int n;
int arr[0];//柔性数组成员
};
//两者都可以
int main()
{
struct S s={0};//这样创建arr是没法使用的
printf("%s\n",sizeof(s));///4
//期望arr的大小是10个int
struct S* ps=(struct S*)malloc(sizeof(struct S)+10*sizeof(int));
//增加
struct S* ptr=(struct S*)realloc(ps,sizeof(struct S)+20*sizeof(int));
if(ptr!=NULL)
{
ps=ptr;
}
free(ps);
ps=NULL;
return 0;
}
- 结构中的柔性数组成员前面必须至少包含一个其他成员
- sizeof返回的这种结构的大小不包含柔性数组
- 包含柔性数组成员的结构用malloc()进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小。
- 尝试代替柔性数组
- malloc两次
- 频繁malloc内存碎片增加
- 内存池!!
- 柔性数组连续,空间局部性更高
struct S{
int n;
int* arr;
};
int main()
{
struct S* ps=(struct S*)malloc(sizeof(struct S));
if(ps==NULL) return 1;
ps->n=10;
ps->arr=(int*)malloc(10*sizeof(int));
if(ps->arr==NULL)
{
return 1;
}
int i=0;
for(i=0;i<10;i++) ps->arr[i]=i;
//增加
int* ptr=realloc(psr->arr,20*sizeof(int));
if(ptr!=NULL)
{
ps->arr=ptr;
}
//使用
//释放
free(ps->arr);
ps->arr=NULL;
free(ps);
ps=NULL;
}
柔性数组优势
- 方便内存释放
- 有利于提高访问速度