目录
如何避免内存泄漏
C和C++的内存分布
- 栈/堆栈:存放非静态局部变量、函数参数、返回值等
- 内存映射段:高效的I/O映射方式,用于装载一个共享的动态内存库,用户可以使用系统接口创建共享内存,做进程通信
- 堆:为程序员准备的空间,堆是可以向上增长的
- 数据段(静态区):存放全局变量、静态全局变量、静态局部变量
- 代码段:可执行的代码、只读常量
1、为什么要分这些区域?
答:更加高效的管理和读取数据
2、这些区域哪个是我们要关注的重点?
答:堆(可以自主控制的区域)
int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
static int staticVar = 1;
int localVar = 1;
int num1[10] = { 1, 2, 3, 4 };
char char2[] = "abcd";
const char* pChar3 = "abcd";
int* ptr1 = (int*)malloc(sizeof(int) * 4);
int* ptr2 = (int*)calloc(4, sizeof(int));
int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
free(ptr1);
free(ptr3);
}
1. 选择题:
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里?__C__ staticGlobalVar在哪里?__C__
staticVar在哪里?__C__ localVar在哪里?__A__
num1 在哪里?__A__
char2在哪里?__A__ *char2在哪里?_A__
pChar3在哪里?__A__ *pChar3在哪里?__D__
ptr1在哪里?__A__ *ptr1在哪里?__B__
sizeof(num1) = __40__;
sizeof(char2) = __5__; strlen(char2) = __4__;
sizeof(pChar3) = __4/8__; strlen(pChar3) = __4__;
sizeof(ptr1) = __4/8__;
数组名是一种特殊的指针
C语言中动态内存管理方式
方式:malloc、calloc、realloc
void Test ()
{
int* p1 = (int*) malloc(sizeof(int));
free(p1);
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
free(p3);
}
1、malloc、calloc、realloc的区别
答:malloc不初始化内存,calloc将内存初始化为0,realloc可以在原空间中也可以在新空间中
2、malloc的实现原理
答:【CTF】GLibc堆利用入门-机制介绍_哔哩哔哩_bilibili
C++内存管理方式
问题:malloc等无法对自定义类型有一个很好的控制
基本概念:C++通过new(动态内存申请)和delete(动态内存释放)操作符进行动态内存管理
操作符在编译时编译器会将其生成调用operator new和operator delete函数的汇编指令
格式:指针类型 指针变量名 = new 要开辟的对象
注意事项:
1、使用new在开辟空间时更简洁
//动态申请一个int类型的空间
int* ptr4 = new int;
int* ptr4 = (int*)malloc(sizeof(int));
2、使用new可以控制初始化
#include <iostream>
using namespace std;
int main()
{
//动态申请一个int类型的对象
int* ptr4 = new int;
//动态申请一个int类型的对象并初始化为10
int* ptr5 = new int(10);
// 动态申请3个int类型的对象
int* ptr6 = new int[3];
//动态申请10个int类型的对象,并初始化前两个对象
int* ptr7 = new int[10]{1,2,5,6,7};
delete ptr4;
delete ptr5;
delete[] ptr6;
delete[] ptr7;
return 0;
}
3、 new对于自定义类型可以在开空间后进行初始化(开空间 + 构造函数),malloc等不可以
#include <iostream>
using namespace std;
struct ListNode
{
ListNode* _next;
int _val;
ListNode(int val)
:_next(nullptr)
,_val(val)
{}
};
//C语言申请结点
struct ListNode* CreateListNode(int val)
{
struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode*));
if (newnode == NULL)
{
perror("malloc fail");
return NULL;
}
newnode->_next = NULL;
newnode->_val = val;
return newnode;
}
//C语言生成链表
......
//C++生成不带哨兵位的单链表 = C语言生成链表 + C语言申请结点(调用构造函数)
ListNode* CreateList(int n)
{
ListNode head(-1);//局部哨兵位
ListNode* tail = &head;
int val;
printf("请依次输入%d个结点的值 >", n);
for (size_t i = 0; i < n; i++)
{
cin >> val;
tail->_next = new ListNode(val);//开空间调用构造函数
tail = tail->_next;
}
return head._next;
}
int main()
{
ListNode* list1 = CreateList(5);
return 0;
}
4、new失败以后会抛异常, 不需要手动检查
5、申请和释放单个空间用new和delete,申请和释放连续空间,用new[]和delete[]
operator new和operator delete
基本概念:operator new和operator delete是系统提供的全局函数,new在底层调用operator new全局函数来申请空间,delete在底层通过operator delete全局函数来释放空间
注意事项:
1、operator new是对malloc的封装
2、operator delete是对free的封装
/*
operator new:该函数实际通过malloc来申请空间,当malloc申请空间成功时直接返回;申请空间
失败,尝试执行空间不足应对措施,如果改应对措施用户设置了,则继续申请,否则抛异常。
*/
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
// try to allocate size bytes
void *p;
while ((p = malloc(size)) == 0)
if (_callnewh(size) == 0)
{
// report no memory
// 如果申请内存失败了,这里会抛出bad_alloc 类型异常
static const std::bad_alloc nomem;
_RAISE(nomem);
}
return (p);
}
/*
operator delete: 该函数最终是通过free来释放空间的
*/
void operator delete(void *pUserData)
{
_CrtMemBlockHeader * pHead;
RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
if (pUserData == NULL)
return;
_mlock(_HEAP_LOCK); /* block other threads */
__TRY
/* get a pointer to memory block header */
pHead = pHdr(pUserData);
/* verify block type */
_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
_free_dbg( pUserData, pHead->nBlockUse );
__FINALLY
_munlock(_HEAP_LOCK); /* release other threads */
__END_TRY_FINALLY
return;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)
3、delete会先调析构函数后释放内存,否则出错
- 开辟:第一块空间是由operator new开辟的,第二块空间是构造函数提供的
- 释放:第二块空间由析构函数释放,第一块空间由operator delete释放
4、delete[]括号内不用写数字,编译器自己会知道要析构的次数(因为如果我们要的是一个四十字节大小的连续空间,系统会分配四十四个字节大小的连续空间,多出来的四个字节用于存放要调用析构函数的次数)
int main()
{ //底层原理:
A* ptr1 = new A; //operator new + 1次构造
A* ptr2 = new A[10]; //operator new[] + 10次构造
delete ptr1; //1次析构 + operator delete
delete[] ptr2; //?次析构 + operator delete
return 0;
}
ptr2指向的地址是0x00EA5184,但是在0x00EA5180地址处还存放了一个10(十六进制的0a)
但并不是所有的情况都会额外提供这几个字节,当我们不写自定义的析构函数而是用编译器提供的默认析构函数时,由于该函数什么都不干所以编译器会觉得没必要再调用它,因此也就没必要存调用析构函数的次数了
5、对于自定义类型new与delete一定要与匹配使用,new[]一定要和delete[]匹配使用,不匹配使用结果是不确定的
int main()
{
int* p1 = new int[10];
delete p1;
A* p2 = new A[10];
delete p2;
return 0;
}
1、对于内置类型,new[]和delete可以配合使用,因为new[]的最底层是malloc,delete的最底层是free,尽管malloc了好几个int类型的对象,但只需要free掉p1这个指针即可free掉malloc开辟的连续空间
2、对于自定义类型,new[]和delete不能配合使用:
- A类实现了析构函数
malloc了44个字节,但实际上p2指向的是第四个字节,由于delete的底层是free,当free调p2指针时相当于选择了一块连续空间中的中间位置开始向后释放空间,这是不对的,报错是因为释放位置错了,如果是delete[]的话会先把p2指针向前偏移四个字节再去free掉后续空间,且能够依据四字节中存放的个数信息多次调用析构函数,避免了因析构函数未调用够而发生的内存泄漏问题
- A类未实现析构函数
A没写析构函数,所以delete不会调用析构函数(编译器提供的析构函数什么都不干),因此不会多开辟那四个字节,就不会产生上述问题
new和delete的实现原理
内置类型
申请内置类型的空间,new/malloc和delete/free基本类似,不同的是new和delete申请和释放的是单个元素的空间,new[]和delete[]申请的是连续空间,且new在申请空间失败时会抛异常,malloc则会返回NULL
自定义类型
new的原理:
- 调用operator new函数申请空间
- 在申请的空间上执行构造函数,完成对象的构造
delete的原理
- 在申请的空间上执行析构函数,完成对对象中资源的清理工作
- 调用operator delete函数释放对象的空间
new A[N]的原理
- 调用operator new[]函数,实现对N个对象空间的申请
- 在申请的N个空间上再分别执行N次构造函数
delete[]的原理
- 调用operator delete[]函数,在申请的N个对象空间上执行分别执行N次析构函数,完成N个对象中资源的清理
- 调用operator delete释放N个对象空间
定位new表达式(placement-new)
基本概念:一般情况下是无法显式调用构造函数(析构函数可以显式调用,但一般不会),但是有时候又需要我们显式调用构造函数(不让用new和delete的情况)
功能:显式调用构造函数对一块已经有的空间进行初始化
//p1指向的只不过是与A对象相同大小的一段空间,还不能算是一个对象,因为构造函数没有执行
A* p1 = (A*)malloc(sizeof(A));
new(p1)A; //如果A类的构造函数有参数时,此处需要传参
p1->~A();
free(p1);
格式:new(指针)类名(参数列表)
使用场景:定位new表达式一般配合内存池使用,因为内存池分配出的内存空间没有初始化,所以如果是自定义类型的对象,需要使用new的定义表达式进行显示调用构造函数进行初始化
malloc/free和new/delete的区别
它们都是从堆上申请空间,并且需要用户手动释放,不同的是:
1、melloc和free是函数,new和delete是操作符
2、malloc申请的空间不可以(会)初始化,new申请的空间可以初始化
3、malloc申请空间时,需要手动计算空间大小(sizeof)并传递,new只需在其后跟上空间类型即可,如果是多个对象,[]中指定对象个数即可
4、malloc的返回值为void*,在使用时必须强转,new不需要,因为new后面跟的是空间的类型
5、malloc申请空间失败时,返回NULL,因此使用时必须判空,new不需要,但是new必须捕获异常
6、申请自定义类型对象时,malloc/free只会开辟空间,不会调用构造函数和析构函数,而new在申请空间后会调用构造函数完成对象初始化,delete在释放空间前会调用析构函数完成空间中资源的清理
内存泄漏
什么是内存泄漏,内存泄漏的危害是什么
基本概念:因疏忽或错误造成程序未能释放已经不再使用的内存的情况,它不是指内存在物理上的消失,而是应用程序分配某段内存后,因为设计错误,失去了对该段内存的控制,因而造成了内存浪费
危害:长期运行的程序出现内存泄漏,影响很大,如操作系统、后台服务等等,出现内存泄漏会导致响应越来越慢,最终卡死
void MemoryLeaks()
{
// 1.内存申请了忘记释放
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
// 2.异常安全问题
int* p3 = new int[10];
Func(); // 这里Func函数抛异常导致 delete[] p3未执行,p3没被释放.
delete[] p3;
}
内存泄漏的分类
C/C++程序中一般我们会关心以下两种内存泄漏:
堆内存泄漏(Heap Leak)
malloc / calloc / realloc / new在堆上申请的空间未用free / delete释放掉,那么以后这段空间不能将无法使用,造成Heap Leak
系统资源泄漏
程序使用系统分配的资源,比如套接字、文件描述符、管道等没有使用函数释放掉,导致程序资源的浪费,严重可导致系统效能减少,系统执行不稳定
_CrtDumpMemoryLeaks函数
基本概念:vs中可以使用windows操作系统提供的_CrtDumpMemoryLeaks()函数进行简单的内存泄漏检测
注意事项:该函数只能报出大概泄漏了多少个字节,没有泄漏位置的信息
#include <iostream>
using namespace std;
int main()
{
int* p = new int[10];
// 将该函数放在main函数之后,每次程序退出的时候就会检测是否存在内存泄漏
_CrtDumpMemoryLeaks();
return 0;
}
Linux下内存泄漏检测:Linux下几款C++程序中的内存泄露检查工具_c++内存泄露工具分析-CSDN博客
windows下使用第三方工具:VS编程内存泄漏:VLD(Visual LeakDetector)内存泄露库_visual leak detector vs2020-CSDN博客
如何避免内存泄漏
1、开辟的空间记得释放
2、使用RAII思想或智能指针来管理资源
3、有些公司内部规范使用内部实现的私有内存管理库,这套库自带内存泄漏检测的功能
4、使用内存泄漏工具检测(但很多都不够靠谱,或高收费)
~over~