1.为什么要动态内存分配
在之前的学习中我们已经掌握的内存开辟方式有:
int num = 20; //在栈空间开辟四个字节
char arr[10] = { 0 }; //在栈空间开辟10个字节的连续空间
上述的开辟空间的方式有两个特点:
•空间开辟大小是固定的。
•数组在申明的时候,必须指定数组的长度,数组空间一旦确定了大小不能调整
但是对于空间的需求,不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知
道,那数组的编译时开辟空间的方式就不能满足了。
C语言引入了动态内存开辟,让程序员自己可以申请和释放空间,就比较灵活了。
2.动态内存函数
2.1 malloc----free
void* malloc ( size_t size );
在使用malloc函数之前要包含头文件 # include <stdlib.h>
malloc函数通常向内存申请一块连续可用的内存空间,并且返回指向该空间的指针。
注意:
1.如果开辟成功,则会返回一个指向已开辟空间的指针。
2.如果开辟失败,则返回一个 NULL 指针,所以开辟完后要检查malloc的返回值。
3.返回值的类型是 void* ,所以 malloc 函数并不知道开辟空间的类型,需要使用者人为规定。
4.如果参数 size 为0,malloc 的行为标准是未定义的,取决于编译器本身。
#include <stdlib.h>
int main()
{
//20 个字节 - 存放5个整数
int* p = (int*)malloc(20);
if (p == NULL)
{
perror("malloc");//判断malloc函数申请是否成功
return 1;
}
//使用空间
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = i + 1;
}
//释放内存
free(p);//传递给free函数的是要释放的内存空间的起始地址
p = NULL;
return 0;
}
free函数是专门用来做动态内存的释放和回收的,函数原型如下:
void free ( void* ptr );
注意:
1.如果参数 ptr 指向的空间不是动态内存开辟的,那 free 函数的行为就是未定义的。
2.如果参数 ptr 是 NULL 指针,则函数不进行任何动作。
3.同样的,free 函数使用前要包含头文件 # include <stdlib.h>
#include<stdlib.h>
int main()
{
//申请20字节的内存空间
int*p = (int*)malloc(5 * sizeof(int));
if (p == NULL)
{
perror("malloc");//判断是否申请成功
return 1;
}
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", *(p + i));
}
free(p);//释放空间
p = NULL;//将p指针置为NULL空指针
return 0;
}
2.2 calloc----realloc
void* calloc (size_t num, size_t size);
calloc 函数和 malloc 函数十分相似,唯一的区别就是把申请空间的每个字节初始化为0。同样包含于头文件 # include <stdlib.h> 中。
如下列代码:
#include<stdio.h>
#include<stdlib.h>
int main()
{
int *p = (int *)calloc(10,sizeof(int));
if(p != NULL)
{
int i = 0;
for(i = 0; i<10; i++)
{
printf("%d ",*(p+i));
}
}
free(p);
p = NULL;
return 0;
}
//打印结果为:0 0 0 0 0 0 0 0 0 0
由此可知,如果我们对申请空间的内容要求初始化,那么可以使用 calloc 函数来很方便的实现。
realloc 函数通常可以对动态内存开辟的大小很方便的进行调整。
void* realloc (void* ptr, size_t size);
其中:
1.ptr 是要调整的地址
2.size 是调整之后新的大小
3.返回值为调整之后内存的首地址(起始位置)
4.realloc 函数在调整原内存空间大小的基础上,还会将原来内存中的数据移到新的内存空间
5.realloc 函数调整大小有两种情况:
第一种情况:原有空间之后有足够的空间用来调整
处理方案:要扩展内存就直接在原有内存之后追加空间,原来空间的数据不发生变化
第二种情况:原有空间之后没有足够大的空间用来调整
处理方案:在堆空间上另外找一个合适大小的连续空间来使用,这样函数会返回一个新 的内存地址
int main()
{
int* p = (int*)malloc(5 * sizeof(int));//申请20字节的内存空间
//1 2 3 4 5
if (p == NULL)
{
perror("malloc");//判断申请是否成功
return 1;
}
//使用
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = i+1;//对申请的内存空间赋值
}
//希望将空间调整为40个字节
int*ptr = (int*)realloc(p, 40);
if (ptr != NULL) //调整成功
{
p = ptr;
int i = 0;
for (i = 5; i < 10; i++)
{
*(p + i) = i + 1;
}
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
free(p);
p = NULL;
}
else //调整失败
{
perror("realloc");//打印错误信息
free(p);//释放内存空间
p = NULL;//将指针p置为空指针
}
return 0;
}
3.常见的动态内存错误
3.1 对 NULL 指针的解引用操作
void test()
{
int *ptr = (int *)malloc(INT_MAX/4)//INT_MAX为int类型的最大范围
*ptr = 20;//如果ptr为NULL就会出现问题
free(ptr);
}
3.2 对动态开辟空间的越界访问
void test()
{
int i = 0;
int* ptr = (int*)malloc(sizeof(int) * 10);
if (ptr != NULL)//保证ptr内存空间开辟成功
{
for (i = 0; i <= 10; i++)
{
*(ptr + i) = i;//当i=10的时候存在越界访问
}
}
free(ptr);
}
3.3 对非动态开辟内存的free释放
void test()
{
int m = 2359;
int* p = &m;
free(p);//err--非动态内存申请空间不可以用free()释放
}
3.4 free函数只释放动态内存空间的一部分
void test()
{
int* ptr = (int*)malloc(sizeof(int) * 10);
ptr++;//指针后移,不在指向首地址
free(ptr);//err--仅释放部分动态内存开辟的内存空间
}
3.5 对同一块动态内存空间的多次释放
void test()
{
int* ptr = (int*)malloc(sizeof(int) * 10);
free(ptr);
free(ptr);//err--二次释放
}
3.6 对开辟的动态内存空间忘记释放导致的内存泄漏
void test()
{
int* ptr = (int*)malloc(sizeof(int) * 100);
if (ptr != NULL)
{
*ptr = 20;
}
}
int main()
{
test();
while (1);
//err--为free释放内存空间导致内存可能泄露
return 0;
}
4.经典笔试例题
4.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;
}
错误原因:
1. GetMemory(char* p)在执行完之后形参直接释放了空间,所以strcpy是对NULL进行拷贝,是对NULL进行解引用操作,程序崩溃
2. 未free释放内存空间,导致内存泄露
//修改后
void GetMemory(char** p)//使用二级指针直接传输地址
{
*p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(&str);
strcpy(str, "hello world");
printf(str);
free(str);//释放动态内存空间
str = NULL;//将指针置为空指针
}
int main()
{
Test();
return 0;
}
4.2
char* GetMemory()
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
printf(str);
}
错误原因:p形参的内存空间出函数后内存空间还给操作系统,str为非法访问,str是野指
4.3
void GetMemory(char** p, int num)
{
*p = (char*)malloc(num);
}
void Test(void)
{
char* str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
错误原因:未释放动态内存
//修改后
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;
}
4.4
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;
}
错误原因: 提前释放掉了str的内存空间,造成非法访问内存空间
//修改后
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;
}
5.柔性数组
5.1柔性数组的特点
1.结构中的柔性数组成员前面至少有一个其他成员
2.sizeof返回的这种结构大小不包括柔性数组的内存
3.包含柔性数组成员的结构用 malloc() 函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小
比如:
typedef struct member
{
int i;//占四个字节
int a[0];//柔性数组成员
} type_s ;
int main()
{
printf("%d ", sizeof(type_s));//结果为4
return 0;
}
5.2 柔性数组的使用
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S));
if (ps == NULL)
return 1;
ps->arr = (int*)malloc(5*sizeof(int));
if (ps->arr == NULL)
return 1;
//使用
ps->n = 100;
int i = 0;
for (i = 0; i < 5; i++)
{
ps->arr[i] = i;
}
//调整数组大小
int*ptr = (int*)realloc(ps->arr, 10*sizeof(int));
if (ptr != NULL)
{
ps->arr = ptr;
}
//使用
//...
//释放
free(ps->arr);
free(ps);
return 0;
}
5.3柔性数组的优势
第一个好处是:方便内存释放
如果我们的代码是在一个给别人用的函数中,你在里面做了二次内存分配,并把整个结构体返回给用户。用户调用free可以释放结构体,但是用户并不知道这个结构体内的成员也需要free,所以你不能指望用户来发现这个事。所以,如果我们把结构体的内存以及其成员要的内存一次性分配好了,并返回给用户一个结构体指针,用户做一次free就可以把所有的内存也给释放掉。
第二个好处是:这样有利于访问速度
连续的内存有益于提高访问速度,也有益于减少内存碎片。