目录
一、动态内存分配
对于以下变量的声明:
int val = 20; (在栈区上开辟四个字节)
char arr[10] = {0}; (在栈区上开辟10个字节的连续空间)
都是在栈区(静态申请的内存的存放地)上申请空间,申请的空间大小是固定不变的。而对于数组,在其声明时必须指定数组的长度,且所需要的内存在编译时才分配。
但对于空间申请的需求,未必是始终固定不变的。
例如,当我们需要空间来存储一些信息,而空间容纳不下,或空间正好填满,但后续无法继续容纳。
这说明,实际所需的空间大小往往在程序运行的时候才能得知,那么,空间大小不变的申请方式,例如数组的编译时开辟空间的方式,有时就无法满足实际需求了。
这时如果空间的大小是可变的、可修改的,也许就能满足实际需求了。
于是就有了“动态内存分配”,即在堆区(动态申请的内存的存放地)上申请空间。
二、动态内存函数
-
malloc
void* malloc(size_t size);
[小结]
1.功能:向内存(堆区)申请一块连续可用的空间,并返回指向这块空间的指针
2.头文件:<stdlib.h>
3.返回类型:void*
4.参数类型:size_t(unsigned int)
[ps]
1>若空间开辟成功,则返回一个指向开辟好的空间的指针。若开辟失败,则返回一个NULL指针。因此malloc的返回值一定要做检查。
2>因为返回值的类型是 void* ,即malloc函数并不知道开辟空间的类型,所以具体使用的时候需使用者自己来决定,即按需对返回类型做强制类型转换
3>若参数size为0,则malloc的行为是标准是未定义的,实际取决于编译器。
4>malloc是在堆区上申请空间,空间使用完后需要释放
-
free
void free (void* ptr);
[小结]
1.功能:释放动态申请的内存
2.头文件:<stdlib.h>
3.返回类型:void
4.参数类型:void*
[ps]
1>如果参数 ptr 指向的空间不是动态申请的,那free函数的行为是未定义的。
如果参数 ptr 是NULL指针,则函数什么事都不做。
2>释放内存后,动态申请的空间会被回收给内存,该空间无法将再使用
3>对动态申请的空间只能释放一次,不可重复释放
4>不可用于释放静态申请的空间
[ 例 ]
int main()
{
//申请40个字节,用来存放10个整型
int* p = (int*)malloc(40);
//检验是否开辟成功
if (p == NULL) //创建失败则返回空指针
{
printf("%s\n", strerror(errno)); //探究错误类型,
return 1; //且不继续执行
}
//存放1~10到开辟的动态空间中
int i = 0;
/*
for (i = 0; i < 10; i++)
{
*(p + i) = i + 1;
}*/
//打印malloc赋值前储存的值
for (i = 0; i < 10; i++)
{
printf("%d\n", *(p + i)); //随机值
}
//释放申请的内存
free(p);
p = NULL;
//free()释放内存,将申请的空间回收给内存,使该空间无法再使用,但并不会将p置为空
//(即p的值并不改变),故后续使用p可能存在非法访问。主动置p为空,防止非法访问。
return 0;
}
[补] 动态申请内存与一般静态申请内存的不同点在于,静态申请的内存是放在栈区的,而动态申请的内存是放在堆区的。栈区的特点是申请的内存不需要手动释放,一个变量的生命周期结束后系统会自动将其释放;而堆区需要手动释放,如果不手动释放,则有可能会造成内存泄漏等重大问题(内存泄漏是指,一个程序在运行时所占用的内存不断增大,不及时处理会导致计算机内存占用过多)。所以我们使用动态申请的内存结束后,一定要将其释放。
[注] free释放空间只对动态申请的空间起用,不可以手动释放静态申请的空间,且对动态申请的空间只能手动释放一次,不可重复释放。
-
calloc
void* calloc (size_t num, size_t size);
[小结]
1.功能:开辟num个大小为size的动态空间,并把空间的每个字节初始化为0
2.头文件:<stdlib.h>
3.返回类型:void*
4.参数类型:size_t的空间数量和空间大小
[ps]
1>calloc相对于malloc的区别只是,calloc会把空间的每个字节初始化为0。
2>malloc、calloc都是在堆区上申请空间,空间使用完后都要释放
3>malloc申请到的空间没有初始化,直接返回起始地址;
calloc申请空间后会将空间全部初始化为0,然后才返回起始地址
[ 例 ]
int main()
{
int*p = (int*)calloc(10, sizeof(int));
if (NULL == p)
{
perror("calloc");
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i)); //全为0
}
//释放
free(p);
p = NULL;
return 0;
}
-
realloc
void* realloc(void* ptr, size_t size);
[小结]
1.功能:调整已申请的动态空间的大小
2.头文件:<stdlib.h>
3.返回类型:void*
4.参数类型:void* - 调整的内存地址,size_t - 调整后的大小
[ps]
realloc函数的意义,是让动态内存管理更加灵活。
有时过去申请的空间太小了,有时候申请的空间过大了,
这时为了合理地使用内存,就需要对动态空间的大小做灵活的调整。
realloc 函数就可以做到对动态申请内存的大小的灵活调整。
[ 例 ]
int main()
{
int*p = (int*)malloc(5 * sizeof(int));
if(NULL == p)
{
perror("malloc");
return 1;
}
//使用
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = 1;
}
//不够了,增加5个整型的空间
int* ptr = (int*)realloc(p, 1000*sizeof(int)); //用新指针接收
if (ptr != NULL)
{
p = ptr;
ptr = NULL;
}
//继续使用空间
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
//释放空间
free(p);
p = NULL;
return 0;
}
[补] 若原本的空间之后有足够的空间可用于扩容,则realloc会直接在原本的空间后面续上新的空间,并返回旧的起始地址。 若原本的空间之后没有足够的空间用于扩容,则realloc会另找一个满足空间大小需求的新连续空间,从新空间的头位置开始,将旧空间的数据拷贝至新空间,并将旧空间释放,返回新空间的起始地址。
int main()
{
int*p = (int*)realloc(NULL, 40);
//如此书写,功能和malloc相同
return 0;
}
三、常见的动态内存错误/误区
3.1 对NULL指针的解引用操作
int main()
{
int* p = (int*)malloc(100);
//若malloc申请失败,则p就为NULL指针了,此时不可对p进行非法的解引用操作
//故每次申请后应对malloc的返回值进行判断:
//if (NULL == p)
// {
// perror("malloc fail");
// return;
// }
int i = 0;
for (i = 0; i < 20; i++)
{
*(p + i) = 0;
}
return 0;
}
3.2 对动态开辟空间的越界访问
int main()
{
int*p = (int*)malloc(100); //空间只能存放25个整型,而非100个
if (p == NULL)
{
return 1;
}
int i = 0;
for (i = 0; i < 100; i++)
{
//*(p + i) = 0; //越界访问
p[i] = 0; //越界访问
}
free(p);
p = NULL;
return 0;
}
3.3 对非动态开辟内存使用free释放
int main()
{
int a = 10; //整型变量存放在栈区
int* p = &a;
free(p); //对堆区释放 //编译器报错
p = NULL;
return 0;
}
3.4 使用free释放一块动态开辟内存的一部分
int main()
{
int*p = (int*)malloc(100);
if (p == NULL)
{
return 1;
}
int i = 0;
for (i = 0; i < 25; i++)
{
*p = i;
p++;
}
free(p); //此时p已经不指向起始位置
p = NULL;
return 0;
}
3.5 对同一块动态内存多次释放
int main()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return 1;
}
free(p);
p = NULL; //没有这句,下面会报错
free(p); //已有上句,free()不干事
return 0;
}
3.6 动态开辟内存忘记释放(内存泄漏)
void test()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return 1;
}
free(p);
p = NULL;
}
int* test()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return 1;
}
return p; //函数内部进行了malloc操作,返回了malloc开辟的空间的起始地址
int main()
}
{
int*ptr = test();
free(ptr);
ptr = NULL;
return 0;
}
//忘记释放不再使用的动态开辟的空间会造成内存泄漏。
//切记:动态开辟的空间一定要释放,且要正确释放。
//但就算开辟和释放成对出现,仍可能存在问题
void test()
{
int* p = (int*)malloc(100);
if (NULL == p)
{
return;
}
if (1)
return;
free(p); //有可能没机会执行
p = NULL;
}
int main()
{
test();
return 0;
}
//故,开辟和释放成对出现,且释放要执行成功
[ 补 ] 相关笔试题
1.动态空间的非法访问+内存泄露
//请问运行test函数会有什么样的结果?
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.str传给p时,p是str的临时拷贝,有自己独立的空间。
// 当GetMemory函数内部申请了空间后,地址放在p中,但str依然为空。
// 当函数返回之后,strcpy拷贝时就发生了非法访问内存。
//2.在GetMemory函数内部动态申请了内存,但没有释放,可能会发生内存泄露。
//修改:
//法1 二级指针传参
void GetMemory(char** p) //二级指针存的是一级指针的地址
{
*p = (char*)malloc(100);
//判断是否开辟成功、p是否为空等小细节,此处略
}
void Test(void)
{
char* str = NULL;
GetMemory(&str); //传址调用
strcpy(str, "hello world");
printf(str);
free(str); //释放
str = NULL;
}
int main()
{
Test();
return 0;
}
//法2 设定GetMemory的返回类型为char*
char* GetMemory()
{
char* p = (char*)malloc(100);
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
strcpy(str, "hello world");
printf(str);
free(str); //释放
str = NULL;
}
int main()
{
Test();
return 0;
}
//[补]
int main()
{
char* p = "hehe\n";
printf("hehe\n");
printf(p);//与上一句等价
return 0;
}
2.返回栈空间地址的问题
//请问运行test函数会有什么样的结果?
char* GetMemory(void)
{
char p[]="hello world"; //在栈上开辟空间
return p; //返回“h”的地址后,空间销毁
}
void Test(void)
{
char* str = NULL;
str = GetMemory(); //赋值“h”的地址,但空间被销毁,访问空间则发生非法访问
printf(str); //打印出随机值
}
int main()
{
test();
return 0;
}
//修改:
char* GetMemory(void)
{
//char* p[]="hello world"
static char p[]="hello world"; //将空间开辟至静态区
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
printf(str); //hello world
}
int main()
{
test();
return 0;
}
//其他类似的例子:
int* test()
{
int a = 10; //脱离函数后,a被销毁
return &a;
}
int main()
{
int* p = test();
printf("%d\n", *p); //可能是10,可能是随机值
return 0;
}
// - - - - - -
int* test()
{
int a = 10;
return &a;
}
int main()
{
int* p = test();
printf("hehe\n"); //printf函数调用时,栈帧可能覆盖掉a的空间
printf("%d\n", *p); //VS2019下打印出:5(故生成随机值)
return 0;
}
3.内存泄露
//请问运行test函数会有什么样的结果?
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;
}
int main()
{
Test();
return 0;
}
4.释放后未置空
//请问运行test函数会有什么样的结果?
void Test(void)
{
char* str= (char*)malloc(100);
strcpy(str, "hello");
free(str); //释放后,str为野指针。故应添加:str=NULL;
if(str!=NULL)
{
strcpy(str, "world"); //非法访问
printf(str);
}
}
int main()
{
Test();
return 0;
}
[ 补 ] C/C++程序的内存开辟
1. 栈区(stack):在函数执行时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区(heap):一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。分配方式类似于链表。
3. 数据段(静态区/static)存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段:存放函数体(类成员函数和全局函数)的二进制代码。
实际上普通的局部变量是在栈区分配空间的,栈区的特点是在上面创建的变量出了作用域就销毁。但是被static修饰的变量存放在数据段(静态区),数据段的特点是在上面创建的变量,直到程序结束才销毁,所以生命周期变长。
[ 补 ] 柔性数组
C99标准中,结构体中的最后一个元素允许是未知大小的数组,这就叫做『柔性数组』成员。
//如:
struct s
{
int i;
int a[0]; //柔性数组成员 数组的大小是未知的
//int a[]; //上句在部分编译器中会报错无法编译,可以改成这句
};
//1> 结构中的柔性数组成员前面必须至少一个其他成员。
//2> sizeof 返回的这种结构大小不包括柔性数组的内存。
例:
struct s
{
int n;//4
char a[];
};
int main()
{
printf("%d\n", sizeof(s));//4
}
//3> 包含柔性数组成员的结构用malloc()函数进行内存的动态分配,并且分配的内存应该大于结构的大小,
// 以适应柔性数组的预期大小。
例:
struct S
{
int n;//4
char arr[];
};
int main()
{
//创建
struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(char));
//赋值
ps->n = 100;
int i = 0;
for (i = 0; i < 10; i++)
{
ps->arr[i] = 'Q';
}
//打印
for (i = 0; i < 10; i++)
{
printf("%c ", ps->arr[i]);
}
//增容
struct S* ptr = (struct S*)realloc(ps, sizeof(struct S)+20*sizeof(char));
if (ptr != NULL)
{
ps = ptr;
}
else
{
perror("realloc");
return 1;
}
//使用
//...
//释放
free(ps);
ps = NULL;
}
//类比:
struct S
{
int n;
char* arr;//·
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S));
if (ps == NULL)
{
perror("malloc");
return 1;
}
ps->n = 100;
ps->arr = (char*)malloc(sizeof(char)*10);
if (ps->arr == NULL)
{
perror("malloc->arr");
return 1;
}
//使用
int i = 0;
for (i = 0; i < 10; i++)
{
ps->arr[i] = 'Q';
}
//增加
char* ptr = (char*)realloc(ps->arr, 20*sizeof(char));
if (ptr != NULL)
{
ps->arr = ptr;
}
else
{
perror("realloc->ptr");
return 1;
}
//使用
//...
//释放
free(ps->arr);
ps->arr = NULL;
free(ps);
ps = NULL;
return 0;
}
[小结]
1.柔性数组,malloc一次、free一次,过程不易出错,且空间连续,利于减少内存碎片,访问效率高。
2.普通指针,malloc两次、free两次,过程易出错,且空间不连续,可能出现内存碎片,访问效率低。