文章目录
- 前言
- 一、C/C++内存分布
- 二、C语言中动态内存管理方式:malloc/calloc/realloc/free
- 三、C++内存管理方式
-
- [ 3.1 new/delete操作内置类型](# 3.1 new/delete操作内置类型)
- [ 3.2 new和delete操作自定义类型](# 3.2 new和delete操作自定义类型)
- [ 3.3 operator new与operator delete函数](# 3.3 operator new与operator delete函数)
- 四、new和delete的实现原理
-
- [ 4.1 内置类型](# 4.1 内置类型)
- [ 4.2 自定义类型](# 4.2 自定义类型)
-
- [ 4.2.1 底层原理分析](# 4.2.1 底层原理分析)
- [ 4.2.2 示例(栈)](# 4.2.2 示例(栈))
- [五、 扩展思考](#五、 扩展思考)
-
- [ 5.1 delete[] 为什么不需要写释放个数?](# 5.1 delete[] 为什么不需要写释放个数?)
- [ 5.2 构造个数与析构个数不匹配](# 5.2 构造个数与析构个数不匹配)
- 六、malloc/free和new/delete的区别
- 总结
前言
本文在C语言基本内存管理知识的基础上,介绍了C++的动态内存管理的不同之处,旨在帮助读者复习C,进而过渡到C++
一、C/C++内存分布
我们先来看下面的一段代码和相关问题,回顾复习一下C语言的知识
cpp
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在哪里?____ staticGlobalVar在哪里?____
staticVar在哪里?____ localVar在哪里?____
num1 在哪里?____
char2在哪里?____ *char2在哪里?___
pChar3在哪里?____ *pChar3在哪里?____
ptr1在哪里?____ *ptr1在哪里?____
2. 填空题:
sizeof(num1) = ____;
sizeof(char2) = ____; strlen(char2) = ____;
sizeof(pChar3) = ____; strlen(pChar3) = ____;
sizeof(ptr1) = ____;
3. sizeof 和 strlen 区别?
- 易错
cpp
char2[] = "abcd" //开辟一个数组,将字符串abcd赋值拷贝进去
const char* pchar3 = "abcd" //创建一个指针指向常量字符串"abcd"
*char2 //解引用数组名,拿到的是首元素地址,不是拿到常量字符串
二、C语言中动态内存管理方式:malloc/calloc/realloc/free
cpp
void Test()
{
int* p1 = (int*)malloc(sizeof(int));
free(p1);
// 1.malloc/calloc/realloc的区别是什么?
int* p2 = (int*)calloc(4, sizeof(int));
int* p3 = (int*)realloc(p2, sizeof(int) * 10);
// 2.这里需要free(p2)吗?不需要,理由如下
free(p3);
}
c
malloc 动态开辟
calloc 动态开辟 + 初始化为0
realloc 动态调整 //原空间内存充足则原地调整
//不足则异地调整,另外开辟一片空间将原数据拷贝过去且自动销毁原空间
三、C++内存管理方式
C语言内存管理方式在C++中可以继续使用,但有些地方就无能为力,而且使用起来比较麻烦,因此C++又提出了自己的内存管理方式:通过new和delete操作符进行动态内存管理(分别对应malloc,free),往后我们将很少使用到C的内存管理方法。
3.1 new/delete操作内置类型
cpp
void Test()
{
// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请3个int类型的空间
int* ptr6 = new int[3];
delete ptr4;
delete ptr5;
delete[] ptr6;
}
申请和释放单个元素的空间,使用new和delete操作符,申请和释放连续的空间,使用new[]和delete[],注意:匹配起来使用。(思考:如果不匹配会发生什么?后续在 5.2 处我们进行解答)
3.2 new和delete操作自定义类型
cpp
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl; //标识调用了构造函数
}
~A()
{
cout << "~A():" << this << endl; //标识调用了析构函数
}
private:
int _a;
};
int main()
{
// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
A* p1 = (A*)malloc(sizeof(A));
A* p2 = new A(1);
free(p1);
delete p2;
// 内置类型是几乎是一样的
int* p3 = (int*)malloc(sizeof(int));
int* p4 = new int;
free(p3);
delete p4;
A* p5 = (A*)malloc(sizeof(A) * 10);
A* p6 = new A[10];
free(p5);
delete[] p6;
return 0;
}
注意:在申请自定义类型的空间时,new会调用构造函数,delete会调用析构函数,而malloc与free不会。
3.3 operator new与operator delete函数
new和delete是用户进行动态内存申请和释放的操作符 ,operator new 和operator delete是系统提供的全局函数(C++),new在底层调用operator new全局函数来申请空间,delete在底层通过operator delete全局函数来释放空间。
- 【operator new 就是对 malloc 的封装,相当于 malloc + 报错功能(抛异常)】
- 【operator delete 就是对 free 的封装】
下面我们来粗略看一下VS中的汇编代码
cpp
/*
operator new:该函数实际通过malloc来申请空间,当malloc申请空间成功时直接返回;申请空间
失败,尝试执行空间不足应对措施,如果改应对措施用户设置了,则继续申请,否则抛异常。
*/
void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
void* p;
while ((p = malloc(size)) == 0) //调用malloc
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);
__TRY
pHead = pHdr(pUserData);
_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
_free_dbg(pUserData, pHead->nBlockUse); //调用_free_dbg ,实际就是free的底层
__FINALLY
_munlock(_HEAP_LOCK);
__END_TRY_FINALLY
return;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)
四、new和delete的实现原理
4.1 内置类型
如果申请的是内置类型的空间,new和malloc,delete和free基本类似,不同的地方是:
new/delete申请和释放的是单个元素的空间,new[]和delete[]申请的是连续空间,而且new在申请空间失败时会抛异常,malloc会返回NULL
4.2 自定义类型
4.2.1 底层原理分析
- new的原理(operator new + 构造函数)
- 调用operator new函数申请空间
- 在申请的空间上执行构造函数,完成对象的构造
- delete的原理(operator delete + 析构函数)
- 在空间上执行析构函数,完成对象中资源的清理工作
- 调用operator delete函数释放对象的空间
- new T[N]的原理(operator new []+ 构造函数)
- 调用operator new[]函数,在operator new[]中实际调用operator new函数完成N个对
象空间的申请- 在申请的空间上执行N次构造函数
- delete[]的原理(operator delete[] + 析构函数)
- 在释放的对象空间上执行N次析构函数,完成N个对象中资源的清理
- 调用operator delete[]释放空间,实际在operator delete[]中调用operator delete来释
放空间
4.2.2 示例(栈)
五、 扩展思考
5.1 delete[] 为什么不需要写释放个数?
new[] 开空间时会格外开辟一个对应类型大小的空间,用以存储开辟的个数(语法上delete[] 中不需要写个数,但实际上编译器要用,从多开的空间中拿)
5.2 构造个数与析构个数不匹配
cpp
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
//手动实现析构,会报错
//未实现,可能会报错(取决于编译器是否优化)
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
// 记住,一定要匹配使用,不匹配结果是不确定的
int main()
{
int* p1 = new int[10];
delete p1;
A* p2 = new A[10];
delete p2;
return 0;
}
结论:
- 手动实现析构函数时,会报错。原因如上一图。
- 未手动实现时,可能不会报错。
【隐患】析构函数可能本来需要起释放资源的作用,但用户忘记手动写了,不会报错,但会造成内存泄漏 。
【原因】编译器如果进行优化,就不会报错,原因如上二图;如果编译器不进行优化,会报错。
六、malloc/free和new/delete的区别
- 共同点是:都是从堆上申请空间,并且需要用户手动释放。
- 不同的地方是:
- malloc和free是函数,new和delete是操作符
- malloc申请的空间不会初始化,new可以初始化
- malloc申请空间时,需要手动计算空间大小并传递,new只需在其后跟上空间的类型即可,如果是多个对象,[]中指定对象个数即可
- malloc的返回值为void*, 在使用时必须强转,new不需要,因为new后跟的是空间的类型
- malloc申请空间失败时,返回的是NULL,因此使用时必须判空,new不需要,但是new需要捕获异常
- 申请自定义类型对象时,malloc/free只会开辟空间,不会调用构造函数与析构函数,而new在申请空间后会调用构造函数完成对象的初始化,delete在释放空间前会调用析构函数完成空间中资源的清理
总结
本文介绍了C++的动态内存管理的常用知识,旨在帮助读者复习C,快速过渡到C++