目录
为什么要有动态内存分配
int val = 20 ; // 在栈空间上开辟四个字节的连续空间char arr[ 10 ] = { 0 }; // 在栈空间上开辟十 个字节的连续空间
• 空间开辟⼤⼩固定• 数组声明时,必须指定数组的⻓度,长度⼀旦确定了便不能调整
malloc函数
函数原型:void* malloc(size_t size);
作用:向内存申请一块连续可用的内存空间,并返回指向这块内存空间的指针
包含头文件:<stdlib.h>
注意事项:
1、返回的是无类型指针void*,在使用时一定要强制转换为所需要的类型
2、使用完开辟的内存空间后一定要释放空间,如果不释放会造成内存泄漏
3、如果开辟成功,则返回一个指向开辟好空间的指针
4、如果开辟失败,则返回一个NULL指针
5、size的值为0时,它将分配一个大小为0的内存块,并返回一个指向该内存块的指针。但是需要注意的是,这个指针可能是无效的,因为在分配大小为0的内存块时,并不会真正地分配任何内存空间,所以最终情况还是要看编译器的反应
6、动态内存分配相关的函数,它们要操作或者申请的的内存空间属于内存中的堆区
#include <stdio.h>
#include <stdlib.h>
int main()
{
//申请10个整型(40个字节)的空间
int* p = (int*)malloc(10 * sizeof(int));
//判断内存空间是否非开辟成功
if (p == NULL)
{
perror("malloc"); 如果开辟失败就是用perror函数返回错误信息
return 1;
}
//使用空间
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
return 0;
}
free函数
函数原型:void free (void* ptr);
作用:对申请的动态内存空间进行释放
包含头文件:<stdlib.h>
注意事项:
1、如果ptr指向的内存空间不是动态开辟的,那free函数的行为是未定义的
2、如果ptr是NULL指针,则函数什么事都不做
3、free仅释放了空间里数据,但空间的地址仍未释放,需要将指向开辟空间地址的指针置为空
#include <stdio.h>
#include <stdlib.h>
int main()
{
//申请10个整型(40个字节)的空间
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用空间
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
free(p); //释放p所指向的动态内存
p = NULL;
return 0;
}
calloc函数
函数原型:void* calloc (size_t num,size_t size);
作用:为num个大小为size的元素开辟一块空间,并把空间的每个字节初始化为0
包含头文件:<stdlib.h>
注意事项:
1、与malloc函数的区别只在于calloc会在返回地址前,将申请的空间中的每个字节都初始化为0
#include <stdio.h>
#include <stdlib.h>
int main()
{
//申请10个整型(40个字节)的空间
int* p = (int*)calloc(10,sizeof(int));
if (p == NULL)
{
perror("calloc");
return 1;
}
//使用空间
int i = 0;
/*for (i = 0; i < 10; i++)
{
*(p + i) = i;
}*/
for (i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
free(p); //释放p所指向的动态内存
p = NULL;//free只是释放了空间是空间的地址仍未释放
return 0;
}
realloc函数
函数原型:void* realloc(void* ptr,size_t size);
作用:使动态内存管理更加灵活,对申请的动态内存大小进行调整
包含头文件:<stdlib.h>
注意事项:
1、返回调整后的内存起始地址,ptr指向要调整的内存空间,size为调整后的大小
2、内存空间调整后,原内存中的数据移动到新空间,并释放原空间
3、ralloc在调整内存空间时存在两种情况:原有空间够和空间不够
①原有空间足够(返回地址为旧地址)
②原有空间不够(返回地址为新地址,但原来指向该地址的指针仍然存在)
#include <stdio.h>
#include <stdlib.h>
int main()
{
//malloc申请五个字节的内存空间
int* p = (int*)malloc(5 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
int i = 0;
for(i = 0; i < 5; i++)
{
*(p + i) = i + 1;
}
for (i = 0; i < 5; i++)
{
printf("%d ", *(p + i));
}
int* ptr = (int*)realloc(p, 400);
if (ptr != NULL) //扩容成功
{
p = ptr; //还是要使用原来的p就把新地址赋值给p
ptr = NULL; //此时ptr为空指针所以将ptr设置为空
}
else //扩容失败报错
{
perror("realloc");
return 1;
}
free(p);
p = NULL;
return 0;
}
关于“int* ptr = (int*)realloc(p, 400);”和“p = ptr;”解释:
进行扩容时,ptr是指向新空间的指针,如果扩容成功的同时我们还想继续使用原来的p指针只需要将ptr所指向的地址赋值给p(虽然被扩容了原来空间不存在了但是p指针指向的地址仍然保留),此时ptr变成空指针了所以要将NULL赋值给ptr,但是注意在赋值结束后不能对ptr进行free操作否则新申请的内存空间就会被释放且ptr和p都会变成野指针
tips:当realloc函数的第一个参数是NULL指针的时候,功能类似于malloc函数
int*p = (int*)realloc(NULL,40); //malloc(40)
常见的动态内存的错误
对空指针的解引用操作
#include <stdio.h>
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
return 0;
}
如果不添加对p指针的判断,当malloc函数开辟空间失败返回空指针p的时候,下面对于p+i的解引用就变成了对空指针的解引用,但是空指针只能被取地址但是不能被解引用所以出错
tips:
return 0 代表程序正常退出
return 1 代表程序异常退出
free掉部分动态开辟的内存
#include <stdio.h>
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
perror("malloc");
return 1;
}
int i = 0;
for (i = 0; i < 5; i++)
{
*p = i + 1;
p++;
}
free(p);
p = NULL;
return 0;
}
动态开辟内存未释放(内存泄漏)
#include <stdio.h>
void test()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
return;
}
//......
if (5 == 3 + 2)
{
return;
}
free(p);
p = NULL;
}
int main()
{
test();
return 0;
}
程序运行结束后free(p)的操作没有起作用,或者说test函数结束时开辟的内存空间仍未被释放,这是因为在if(5 == 3+2)的操作时函数直接返回了并未进行free操作,这种未释放开辟的内存空间的问题就叫内存泄漏
动态内存经典笔试题:
#include <stdio.h>
#include <string.h>
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void Test()
{
char* str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str); //语法正确
}
int main()
{
Test();
return 0;
}
这个程序的问题在于,str原本是一个空指针,现在将str的值传递给了GetMemory中的指针p该过程属于传值调用(形参是实参的拷贝对形参的操作不会影响实参),然后malloc函数开辟内存空间,当GetMemory函数结束后p指针被释放但开辟的内存空间不会被释放,同时也没有一个指针指向该空间,最后str依然是一个空指针,所以无法将hello world拷贝给str指向的内存空间
该程序正确的写法如下:
#include <stdio.h>
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;
}
有关传值调用和传址调用中的指针的值和指针的地址的补充:
指针的值:即指针变量的值,指针str的值为NULL,所以传址调用传递给p的就是NULL。
指针的地址:即对指针&后得到的值,形参是二级指针
我们将实参设置为str的地址、形参设置为char** p,此时p为二级指针它指向一级指针str所在的地址,接着我们对p解引用得到的就是一级指针str所在的地址,就可以实现对str指向空间的修改。
柔性数组
柔性数组是为了配合动态内存管理的使用,满足以下三条要求的数组我们称之为柔性数组:
1、必须位于结构体中
2、必须为最后一个成员(前面必须要有成员)
3、数组的大小必须未知
柔性数组的特点:
1、sizeof返回的结构体大小不包括柔性数组的大小
2、包含柔性数组成员的结构体⽤malloc 函数进⾏内存的动态分配,并且分配的内存应该⼤于结构体的⼤⼩,以适应柔性数组的预期⼤⼩
柔性数组的使用
#include <stdio.h>
struct st_type
{
int i;
int a[]; //柔性数组
};
int main()
{
//使用malloc开辟44个字节的空间 = 结构体成员大小 + 想要的柔性数组大小
struct st_type* p = (struct st_type*)malloc(sizeof(struct st_type) + 10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用过程
int i = 0;
p->i = 100;
for (i = 0; i < 10; i++)
{
p->a[i] = i;
}
//希望结构中的a数组长度变为60个字节
struct st_type* ptr = (struct st_type*)realloc(p,sizeof(struct st_type) + 15 * sizeof(int));
if (ptr != NULL)
{
p = ptr;
ptr = NULL;
}
else
{
perror("realloc");
return 1;
}
return 0;
}
同样的我们可以使用以下代码实现和柔性数组一样的功能:
#include <stdio.h>
struct st_type
{
int i;
int* a; //柔性数组
//在VS中int a[0]的形式也可以,但是不同编译器可能只能用其中一种
};
int main()
{
//使用malloc开辟一个大小为空间结构体大小的空间
struct st_type* p = (struct st_type*)malloc(sizeof(struct st_type));
//对开辟失败的判断
if (p == NULL)
{
perror("malloc");
return 1;
}
//为结构体成员i赋值
p->i = 100;
//使用malloc为柔性数组开辟一个40字节大小的空间
p->a = malloc(10*sizeiof(int));
if(p->a == NULL)
{
perror("malloc");
return 1;
}
//给a指向的空间进行初始化,因为a指向的是一片空间所以可以视为数组
for (i = 0; i < 10; i++)
{
p->a[i] = i;
}
//后面我们又希望a指向的空间为15个整型
int* ptr = (int*)realloc(p->a,15 * sizeof(int));
if (ptr == NULL)
{
perror("realloc");
return 1;
}
else
{
p->a = ptr;
ptr = NULL;
}
//使用过程
free(p->a);
p->a = NULL;
free(p)
p = NULL;
return 0;
}
对于前后两者之间的对比:前者(使用一次malloc):⽅便内存释放如果我们的代码是在⼀个给别⼈⽤的函数中,你在⾥⾯做了⼆次内存分配,并把整个结构体返回给⽤⼾。⽤⼾调⽤free可以释放结构体,但是⽤⼾并不知道这个结构体内的成员也需要free,所以你不能指望⽤⼾来发现这个事。所以,如果我们把结构体的内存以及其成员要的内存⼀次性分配好了,并返回给⽤⼾⼀个结构体指针,⽤⼾做⼀次free就可以把所有的内存也给释放掉。后者(使用多次malloc):这样有利于访问速度连续的内存空间有益于提⾼访问速度,也有益于减少内存碎⽚, 但其实没提高多少 ......
内存碎片
malloc申请内存空间时分配的内存空间是随机的,图中空白区域就是分配后剩余的内存碎片:
申请次数越多内存碎片越多
C/C++中程序内存区域划分
简单了解
栈区(stack): 在执⾏函数时,函数内局部变量的存储单元都可以在栈上创建,函数执⾏结束时这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中,效率很⾼,但是分配的内存容量有限。 栈区主要存放运⾏函数时需要分配的局部变量、函数参数、返回数据、返回地址等堆区(heap): ⼀般由程序员进行内存空间的分配和释放,若程序员不释放,程序结束时可能由操作系统自己回收,分配⽅式类似于链表数据段/静态区(static): 存放全局变量、静态数据,程序结束后由系统自动释放代码段: 存放函数体(类成员函数和全局函数)的⼆进制代码