C++基础篇之内存管理
文章目录
- C/C++内存分布
- C语言的动态内存管理方式
- C++语言的动态内存管理方式
-
- operator new与operator delete函数
- new和delete的原理
- new/delete操作内置类型
- new/delete操作自定义类型
- operator new/delete的类专属重载
- 定位new表达式
- 内存泄漏
-
- 内存泄漏的定义
- 内存泄露的危害
- 内存泄露的分类
- 内存泄漏的避免方法
- 申请空间失败
C/C++内存分布
C/C++中程序内存可划分：内核空间、栈、内存映射段、堆、数据段和代码段。其中主要需要了解：
| 区域 | 功能 | 内存释放形式 |
|---|---|---|
| 栈 | 存放非静态局部变量、函数参数和返回值等 | 自动 |
| 堆 | 程序动态内存开辟 | 手动 |
| 数据段 | 存放全局变量、静态变量 | 自动 |
| 代码段 | 可执行代码、可读常量 | 自动 |
示例代码：
int globalVar = 1;
static int staticGlobalVar = 1;
int main()
{
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);
return 0;
}
代码中各个变量对应的区域如下图：
C语言的动态内存管理方式
C语言中主要用到malloc/calloc/realloc和free来管理内存，他们三者都可以开辟空间，区别在哪？
- malloc和calloc的区别：malloc不能初始化开辟的空间，而calloc可以把开辟的空间按字节初始化为0；
- malloc和realloc的区别：malloc是对一块没有分配的内存块进行分配，而realloc是对一块已经分配过的空间重新进行分配，realloc根据重新分配的空间大小分为原地扩和异地扩。
C++语言的动态内存管理方式
C++提出了不同于C的方式：通过new和delete操作符进行动态内存管理，同时malloc/calloc/realloc都是函数，而new/delete是操作符。那mallloc/free和new/delete的区别在哪？
共同点：
- 都是从堆上申请空间，并且需要用户手动释放。
不同点：
- malloc和free是函数，new和delete是操作符
- malloc申请的空间不会初始化，new可以初始化
- malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可
- malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
- malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
- 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理
operator new与operator delete函数
operator new 和 operator delete 是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
- 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;
}
PS：operator new和operator delete就是对malloc和free的封装。
new和delete的原理
1. 内置类型
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
2. 自定义类型
new的原理：
（1）调用operator new函数申请空间
（2） 在申请的空间上执行构造函数，完成对象的构造
delete的原理：
（1）在空间上执行析构函数，完成对象中资源的清理工作
（2）调用operator delete函数释放对象的空间
new T[N]的原理：
（1）调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
（2）在申请的空间上执行N次构造函数
delete[]的原理：
（1）在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
（2）调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间
new/delete操作内置类型
对于内置类型，malloc/free和new/delete没有本质区别，只有用法上的区别。
void Test()
{
// 动态申请一个int类型的空间
int* ptr1 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr2 = new int(10);
// 动态申请10个int类型的空间
int* ptr3 = new int[3];
delete ptr1;
ptr1 = nullptr;
delete ptr2;
ptr2 = nullptr;
delete[] ptr3;
ptr3 = nullptr;
}
注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]！！！
int* ptr4 = new int(5);
int* ptr5 = new int[5];
以上两句代码不相等！！！ 第一句是初始化内存空间的值为5，而第二句是初始化5个int类型的内存空间。
PS: C++11支持数组初始化
int* ptr5 = new int[5]{1,2,3};
未初始化的空间默认值为0
new/delete操作自定义类型
class A
{
public:
A(int a = 10)
:_a(a)
{
cout << "A()->" << this << endl;
}
~A()
{
cout << "~A()->" << this << endl;
}
private:
int _a;
};
int main()
{
int* p1 = (int*)malloc(sizeof(A));
int* p2 = (int*)malloc(sizeof(A) * 5);
A* p3 = new A;
A* p4 = new A[5];
free(p1);
p1 = nullptr;
free(p2);
p2 = nullptr;
delete p3;
p3 = nullptr;
delete[] p4;
p4 = nullptr;
return 0;
}
当单步调试的时候，malloc和new执行结束后的监视面板和输出面板为：
free和delete执行结束后的监视面板和输出面板为：
C++提出new和delete主要是解决两个问题：
- 在申请自定义类型的空间时，new会申请空间+调用构造函数，delete会调用析构函数+释放空间，而malloc与free不会！！！
- new失败以后要求抛异常，这样才符合面向对象语言的出错机制。
PS：delete和free一般不会失败，如果失败都是释放空间上存在越界或者释放指针位置不对。
operator new/delete的类专属重载
针对链表的节点ListNode，通过重载类专属 operator new/ operator delete，实现链表节点使用内存池申请和释放内存，提高效率。
class ListNode
{
public:
ListNode(int val)
:_next(nullptr)
, _prev(nullptr)
, _data(val)
{}
void* operator new(size_t n)
{
void* p = nullptr;
// STL中的内存池->空间配置器
p = allocator<ListNode>().allocate(1);
cout << "memory pool allocate" << endl;
return p;
}
void operator delete(void* p)
{
allocator<ListNode>().deallocate((ListNode*)p, 1);
cout << "memory pool deallocate" << endl;
}
private:
ListNode* _next;
ListNode* _prev;
int _data;
};
class List
{
public:
List()
{
_head = new ListNode(-1);
_head->_next = _head;
_head->_prev = _head;
}
void PushBack(int val)
{
ListNode* newnode = new ListNode(val);
ListNode* tail = _head->_prev;
tail->_next = newnode;
newnode->_prev = tail;
newnode->_next = _head;
_head->_prev = newnode;
}
~List()
{
ListNode* cur = _head->_next;
while (cur != _head)
{
ListNode* next = cur->_next;
delete cur;
cur = next;
}
delete _head;
_head = nullptr;
}
private:
ListNode* _head;
};
int main()
{
List L1;
L1.PushBack(1);
L1.PushBack(2);
L1.PushBack(3);
L1.PushBack(4);
return 0;
}
定位new表达式
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：
// place_address必须是一个指针
// initializer-list是类型的初始化列表
new(place_address) type
new(place_address) type(initialzer-list)
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化
使用示例：
class A
{
public:
A(int val)
:_a(val)
{
cout << "A()" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
int main()
{
// 已开辟的空间
A* p1 = (A*)malloc(sizeof(A));
// 定位new初始化
new(p1) A(3);
delete p1;
p1 = nullptr;
return 0;
}
new = operator new函数 + 定位new表达式
A* p2 = new A(3)
delete p2;
// 等价于
A* p3 = (A*)operator new(sizeof(A));
new(p3) A(3); // 类没有默认构造函数时，必须传参
p3->~A(); //实例化对象可以显示调用析构函数，但是不能显示调用构造函数
operator delete(p3);
内存泄漏
内存泄漏的定义
内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。
内存泄露的危害
长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
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;
}
内存泄露的分类
- 堆内存泄漏
通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后没有调用相应的 free或者delete 删掉，那么以后这部分空间将无法再被使用，就会产生Heap Leak。 - 系统资源内存泄漏
程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
内存泄漏的避免方法
- 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。
- 采用RAII思想或者智能指针来管理资源。
- 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
- 出问题了使用内存泄漏工具检测。
申请空间失败
验证malloc和new申请空间失败后，会出现不同的反馈。
- malloc申请空间失败——错误码
int main()
{
// 面向过程的语言，处理错误的方式一般是返回值+错误码
// 申请空间成功
//char* p1 = (char*)malloc(sizeof(char));
// 申请空间失败
char* p1 = (char*)malloc(1024u * 1024u * 1024u * 2u);
if (p1 == nullptr)
{
printf("%d\n", errno);
perror("malloc fail");
}
else
{
printf("%p\n", p1);
}
return 0;
}
- new申请空间失败——抛异常
int main()
{
// 面向对象的语言，处理错误的方式一般是抛异常，C++中也要求出错抛异常
try
{
//char* p2 = new char[1024u * 1024u * 1024u * 1u];
//printf("%p\n", p2);
char* p2 = new char[1024u * 1024u * 1024u * 2u - 1];
printf("%p\n", p2);
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}
PS：如何一次在堆上申请4G的内存？
// 将程序编译成x64的进程，运行下面的程序试试？
#include 