目录
三. operator new与 operator delete函数
一. C/C++的内存分布
C/C++中程序内存区域划分为下图所示
- 栈又叫堆栈——非静态局部变量/函数参数/返回值等等,栈是向下增长的。
- 内存映射段——是高效的I/O映射方式,用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存,做进程间通信(此为linux涉及内容这里不过多介绍)。
- 堆——用于程序运行时动态内存分配,堆是可以向上增长的。
- 数据段——存储全局数据和静态数据。
- 代码段——可执行的代码/只读常量。
分析一下以下代码中的变量在内存中的存储
#include<iostream>
using namespace std;
int g = 1;
static int s=11;
int main()
{
static int ss = 2;
int l = 0;
int num[10] = { 1,1,1,1 };
char ch[] = "abcd";
const char* pch = "aaaa";
int* p1 = (int*)malloc(sizeof(int) * 4);
free(p1);
}
g | 全局变量存储在数据段(静态区) |
s | 静态变量存储在数据段(静态区) |
ss | 静态变量存储在数据段(静态区) |
l | 局部变量存储在 栈区 |
num | 数组存储在栈区 |
ch | 数组存储在栈区 |
*ch | 第一个元素地址存储在栈区 |
pch | 局部变量存储在栈区 |
*pch | 第一个元素地址指向常量字符串在代码段(常量区) |
p1 | 局部变量存储在栈区 |
*p1 | 动态开辟空间第一个元素地址、存储在堆区 |
二. C++内存管理方式
C语言中动态内存管理方式: malloc/calloc/realloc/free
C++中可以继续使用C语言的内存管理方式,但有些地方就有点无能为力,且使用麻烦,因此C++又提出了自己的内存管理方式:通过new和delete操作符进行动态内存管理
1. new/delete操作内置类型
#include<iostream>
using namespace std;
int g = 1;
static int s=11;
int main()
{
//动态申请一个int类型的空间
int* p1 = new int;
//动态申请一个int类型的空间并将其初始化为10
int* p2 = new int(10);
//动态申请10个int类型的空间
int* p3 = new int[3];
delete p1;
delete p2;
delete[] p3;
return 0;
}
注意:申请和释放单个元素的空间,使用new和delete操作符,申请和释放连续空间,使用new[] 和delete[] ,注意:匹配起来使用
2. new/delete操作自定义类型
#include<iostream>
using namespace std;
class A
{
public:
A(int a = 1)
:_a(a)
{
cout << "gouzao" << this << endl;
}
~A()
{
cout << "xigou" << this << endl;
}
private:
int _a;
};
int main()
{
A* p1 = (A*)malloc(sizeof(A));
A* p2 = new A(11);
free(p1);
delete p2;
A* p3 = (A*)malloc(sizeof(A) * 10);
A* p4 = new A[10]{ 1,2,3,4,5,6,7,8,9,10 };
free(p3);
delete[] p4;
int bn = 0;
return 0;
}
在申请自定义空间时,new会调用构造函数,delete会调用析构函数,而malloc与free不会调用。
三. operator new与 operator delete函数
new和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;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)
通过上述两个全局函数的实现,我们可以得知operator new 实际上也是通过malloc 来申请空间,如果malloc 申请空间成功就直接返回,否则执行用户提供的 空间不足应对措施,如果用户提供该措施就继续申请,否则就抛异常。operator delete 最终是通过free来释放空间的。
四. new和delete的实现原理
1. 实现内置类型
若申请的是内置类型的空间,new和malloc,delete和free基本类似,不同的地方是:new/delete申请和释放的是单个元素的空间,new[]和delete[]申请的是连续空间,而且new在申请空间失败时会抛异常,malloc会返回NULL。
代码如下
#include<iostream>
using namespace std;
void fff()
{
int n = 0;
while (1)
{
n++;
void* p1 = new char[1024 * 1024];
cout << p1 << " " << n << endl;
}
}
int main()
{
try
{
fff();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}
结果如下
2. 实现自定义类型
new的原理
- 调用operator new 函数申请空间
- 在申请的空间上执行构造函数,完成对象的构造
delete的原理
- 在空间上执行析构函数,完成对象中的资源的清理工作
- 调用operator delete 函数释放对象的空间
new X[N]的原理
- 调用operator new[] 函数,在operator new [] 中实际调用operator new 函数完成N个对象空间的申请
- 在申请的空间上执行N次构造函数
delete[] 的原理
- 在释放的空间对象上执行N次析构函数,完成N个对象中资源的清理
- 调用operator deletep[]释放空间,实际在operator delete[]中调用operator delete来释放空间
#include<iostream>
using namespace std;
class Pc
{
public:
Pc(int a=110,int b=42)
: _a (a)
, _b(b)
{
cout << "gz Pc 1111 ->" << _a << " " << _b << endl;
}
~Pc()
{
cout << "xg2222" << endl;
}
private:
int _a = 110;
int _b = 42;
};
class Cp
{
public:
Cp(int c=1, int d=2)
:_c(c)
, _d(d)
{
cout << "gz Cp 1111 ->" << _c << " " << _d << endl;
}
private:
int _c;
int _d;
};
以上两个类,分别用以下主函数实现
int main()
{
Pc* p1 = new Pc(1,2);
delete p1;
Cp* p3 =new Cp[10]{ { 1,2 }, { 2,3 }, { 3,4 },{4,5},{5,6},{6,7} };
delete p3;
return 0;
}
执行结果为
正常结束而当主函数代码如下时
int main()
{
Pc* p2 = new Pc[10]{ { 1,2 }, { 2,3 }, { 3,4 },{4,5},{5,6},{6,7} };
delete p2;
return 0;
}
却发生了报错
编译器在开辟数组空间时会在前面多开四个字节空间存储数组大小
这是p3的地址存储
再来看p2的地址存储
数组空间前面有一个额外空间 存储了数组个数(上图蓝色区域第一行)
- 为什么Cp没有开额外空间呢?因为编译器将其优化了,干脆就不调用析构函数了
- 而Pc有析构函数,编译器不会优化 ,释放空间就没有将其释放,所以报错
- 而delete[] 实际上释放的位置,还会往前偏移四个字节再释放
五. 定位new表达式(placement-new)
定位new表达式是在已分配的原始空间中调用构造函数初始化一个对象。
使用格式:
new(place_address) type 或者 new (place_address) type(initialzer-list)
place_address必须是一个指针,initializer-list是类型的初始化列表
使用场景
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化,所以如果是自定义类型的对象,需要使用new的定义表达式进行显式构造函数进行初始化。
如以下代码:
#include<iostream>
using namespace std;
class Pc
{
public:
Pc(int a=110,int b=42)
: _a (a)
, _b(b)
{
cout << "gz Pc 1111 ->" << this << endl;
}
~Pc()
{
cout << "xg2222" << this << endl;
}
private:
int _a = 110;
int _b = 42;
};
int main()
{
Pc* p1 = (Pc*)malloc(sizeof(Pc));
new(p1)Pc(1,2);//如果Pc的构造函数有参数时,此处需要传参
p1->~Pc();
operator delete (p1);
//delete p1;
Pc* p2 = (Pc*)operator new(sizeof(Pc));
new(p2)Pc;
//operator delete (p2);
delete p2;
return 0;
}
operator new 与 operator delete 都是全局函数可以调用
六. malloc/free与new/delete的区别
1. 相同点
malloc/free和new/delete的共同点是:都是从堆上申请空间,并且需要用户手动释放。
2. 不同点
不同点如下
- malloc和free是函数,new和delete是操作符
- malloc申请的空间不会初始化,new可以初始化
- malloc申请空间时,需要手动计算空间大小并传递,new只需要在其后跟上空间的类型即可,如果是多个对象,[]中指定对象个数即可
- malloc的返回值是void* ,在使用时必须强转,new不需要,因为new后跟的是空间的类型
- malloc申请空间失败时,返回的是NULL,因此使用时必须判空,new不需要判空,但是new要捕获异常
- 申请自定义类型对象时,malloc/free只会开辟空间,不会调用构造函数与析构函数,而new在申请空间后会调用构造函数完成对象的初始化,delete在释放空间前会调用析构函数完成空间中资源的清理释放
这篇就到这里啦,喜欢的可以点一下赞
(๑′ᴗ‵๑)I Lᵒᵛᵉᵧₒᵤ❤