文章讲述了C++中的内存管理方式，包括operatornew和operatordelete与C语言malloc和free的关系，以及new,delete,new[],delete[]的操作行为和注意事项。强调了避免new和各种内存操作符混用的重要性。
C语言内存管理方式(malloc, free 等)在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过 new 和 delete 操作符进行动态内存管理。
目录
operator new 和 operator delete
operator new 和 operator delete
在分析 new 和 delete 的实现原理之前，我们先来了解一下 operator new 和 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;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)代码第10行表明 operator new 底层调用了 malloc，第42行和第54行表明 operator delete 底层调用了 free，也就是说 operator new 和 operator delete 封装了 malloc 和 free，但 malloc 失败了会返回 NULL，不符合C++面向对象的特性，operator new 对 malloc 申请空间失败的情况进行了处理，失败了会抛异常。
new 和 delete
在VS2019里考察以下代码
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A()" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
int main()
{
A* p1 = new A(0);
delete p1;
return 0;
}运行结果如下
可以看到，对于自定义类型，在 new 和 delete 的过程中，调用了A的构造函数和析构函数。
转到反汇编
从上面两图中可看出，对于自定义类型，new 会先调用 operator new申请空间，然后调用构造函数，delete 会先调用析构函数，然后调用 operator delete 释放空间，这里编译器优化的问题 operator delete 被隐藏在了更底层。
对于内置类型，new 和 delete 跟 malloc 和 free 并无较大区别，读者可自行验证。
new[num] 和 delete[]
在VS2019里考察以下代码
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A()" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
int main()
{
A* p1 = new A[10];
delete[] p1;
return 0;
}在程序运行过程中，发现 new 会在p1处开40字节的空间用来存放10个对象，在p1前开4字节存放 0x0a 用来向 delete 表明需要析构10次，这也解释了为什么 delete 的写法不是 delete[num]
上述操作符的混用
如果我们将 new，new[num]，delete，delete[] 混用呢？
在VS2019里考察以下代码
int main()
{
int* p1 = new int[10];
delete p1;
return 0;
}程序可以正常运行，甚至把 delete 换成 free，程序也没问题，因为内置类型不需要构造和析构。
若是把内置类型换成自定义类型，程序会出现运行时崩溃的问题。
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A()" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
int main()
{
A* p1 = new A[10];
delete p1;
return 0;
}
这里 delete 后没有方括号，因此，delete 不会将p1前的4个字节识别为析构的次数，并且在释放空间前只析构1次，这就导致了程序崩溃。
若将析构函数注释掉呢？
程序正常运行，因为A的成员变量较少，而且也没有写析构函数，编译器认为后续不需要进行析构，则在 new A[10] 的过程中不会多开4字节存放10，所以后续直接使用 delete，程序也不会崩溃；一旦类的成员变量复杂起来，这种不配对使用就会造成不可预知的后果。
new 和 delete[] 配合使用也会出现问题，读者可自行验证。
总而言之，应避免 new，new[num]，delete，delete[] 混用，因为这会导致不可预知的后果。
结论
new 和 delete
对于内置类型
如果申请的是内置类型的空间，new 和 malloc，delete 和 free 基本类似，不同的地方是：
new/delete 申请和释放的是单个元素的空间，new[] 和 delete[] 申请的是连续空间，而且 new 在申请空间失败时会抛异常，malloc会返回 NULL。
对于自定义类型
new的原理
1. 调用operator new函数申请空间
2. 在申请的空间上执行构造函数，完成对象的构造
delete的原理
1. 在空间上执行析构函数，完成对象中资源的清理工作
2. 调用 operator delete 函数释放对象的空间
new A[N]的原理
1. 调用 operator new[] 函数，在 operator new[] 中实际调用 operator new 函数完成N个对
象空间的申请
2. 在申请的空间上执行N次构造函数
delete[]的原理
1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2. 调用 operator delete[] 释放空间，实际在 operator delete[] 中调用 operator delete 来释
放空间
malloc/free 和 new/delete 的异同点
malloc/free 和 new/delete 的共同点是：都是从堆上申请空间，并且需要用户手动释放。
不同的地方是：
1. malloc 和 free 是函数，new 和 delete 是操作符
2. malloc 申请的空间不会初始化，new 可以初始化
3. malloc 申请空间时，需要手动计算空间大小并传递，new 只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可
4. malloc 的返回值为void*, 在使用时必须强转，new 不需要，因为 new 后跟的是空间的类型
5. malloc 申请空间失败时，返回的是 NULL，因此使用时必须判空，new 不需要，但是 new需要捕获异常
6. 申请自定义类型对象时，malloc/free 只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
