文章目录
- 内存分布
- 内存分布图解
- C语言中动态内存管理方式
- malloc:
- calloc
- realloc
- C++内存管理方式
- 内置类型
- **自定义类型**
- operator new & operator delete
- operator new & operator delete函数
- operator new
- operator delete
- **new T[N]** 与**delete[]**
- **定位new表达式(placement-new)**
- 如何使用
- 注意事项
- malloc/free和new/delete的区别
类和对象三部曲:
[C++] 轻熟类和对象
[C++] 由浅入深理解面向对象思想的组成模块
类和对象:C++11新特性与知识补充
内存分布
内存分布图解
- 栈又叫堆栈–非静态局部变量/函数参数/返回值等等,栈是向下增长的。
- 内存映射段是高效的I/O映射方式,用于装载一个共享的动态内存库。用户可使用系统接口
创建共享共享内存,做进程间通信。- 堆用于程序运行时动态内存分配,堆是可以上增长的。
- 数据段–存储全局数据和静态数据。
- 代码段–可执行的代码/只读常量
C语言中动态内存管理方式
malloc:
void* malloc(size_t size);
- 功能:malloc函数用于在堆上分配一块连续的内存空间。它接受一个参数,即所需内存的大小(以字节为单位),并返回指向这块内存的指针。
- 初始化:malloc不会对分配的内存进行初始化,内存中的内容是未定义的,可能是之前的值或者全零,具体取决于操作系统。
- 使用场景:当不需要初始化内存或者特定初始化时使用。
calloc
void* calloc(size_t num, size_t size);
- 功能:calloc也用于在堆上分配内存,但它接受两个参数,分别是要分配的元素数量和每个元素的大小(以字节为单位)。calloc会确保分配的内存区域中的每个字节都被初始化为零。
- 初始化:与malloc不同,calloc会将分配的内存全部初始化为零,这使得它适合用于数组或结构体等需要初始化为默认值的情况。
- 使用场景:当需要一个清零的内存块时使用,比如初始化数组。
realloc
void* realloc(void* ptr, size_t size);
- 功能:realloc用于调整先前通过malloc、calloc或realloc分配的内存块的大小。它接受两个参数,第一个是之前分配的内存的指针,第二个是新的大小(可以比原来大也可以比原来小)。
- 初始化:realloc不涉及初始化新分配的内存部分,如果扩大了内存块,新增的部分通常也是未定义的值。
- 使用场景:当原先分配的内存大小不再满足需求,需要扩大或减小内存空间时使用。需要注意的是,如果减小内存空间,超出新大小的部分数据会被截断。
C++内存管理方式
内置类型
// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请10个int类型的空间
int* ptr6 = new int[10];delete ptr4;
delete ptr5;
delete[] ptr6;// 其他方式
int* p3 = new int(0);
int* p4 = new int[10]{ 0 };
int* p5 = new int[10]{1,2,3,4,5}; // 未初始化的用0补齐
注意:申请和释放单个元素的空间,使用new和delete操作符,申请和释放连续的空间,使用
new[]
和delete[]
。
自定义类型
A* p1 = (A*)malloc(sizeof(A)); // C
A* p2 = new A(1); // C++A* p1 = new A(1);
A* p2 = new A(2,2); // 隐式类型A aa1(1, 1);
A aa2(2, 2);
A aa3(3, 3);
A* p3 = new A[3]{aa1, aa2, aa3}; A* p4 = new A[3]{ A(1,1), A(2,2), A(3,3)}; // 匿名函数//A aa1 = { 1, 1 };
A* p5 = new A[3]{ {1,1}, {2,2}, {3,3} };
C++中推荐使用
new
和delete
进行内存管理,使用这二者进行内存管理的特点为**“除了开空间还会调用构造函数和析构函数”(原理下章会提及)**
operator new & operator delete
operator new & operator delete函数
operator new
原理:
- **内置类型:**与
malloc
相似- 自定义类型:
- 调用operator new函数申请空间
- 在申请的空间上执行构造函数,完成对象的构造
源码如下
/*
operator new:该函数实际通过malloc来申请空间,当malloc申请空间成功时直接返回;申请空间
失败,尝试执行空 间不足应对措施,如果改应对措施用户设置了,则继续申请,否
则抛异常。
*/
void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{// try to allocate size bytesvoid* 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);// 返回分配的内存指针
}
通过分析源码可得出:
- 在底层会调用
**malloc**
分配内存:函数内部有一个while
循环,通过malloc
分配指定大小的内存。- **会自动抛异常:**当
malloc
返回nullptr
,则调用_callnewh
尝试处理内存不足的情况,若仍然无法分配内存,则抛出std::bad_alloc
异常。- 在语法层面上会调用构造函数:
new
操作符分配内存后,会在分配的内存上调用构造函数,完成对象的初始化。
operator delete
原理:
- **内置类型:**与
free
基本类似- 自定义类型:
- 在空间上执行析构函数,完成对象中资源的清理工作
- 调用operator delete函数释放对象的空间
源码如下:
/*
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/* 获取指针指向内存块的头信息 */pHead = pHdr(pUserData);/* verify block type */_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));_free_dbg(pUserData, pHead->nBlockUse); // 使用_free_dbg进行内存的释放__FINALLY_munlock(_HEAP_LOCK); /* release other threads */__END_TRY_FINALLYreturn;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)
源码分析:
#define free(p) _free_dbg(p, _NORMAL_BLOCK)
我们可以发现,free
的底层其实是一个宏,最终还是使用_free_dbg(p, _NORMAL_BLOCK)
进行内存释放。- 通过第一点分析可得,
delete
的底层也是通过free
,或者说_free_dbg(p, _NORMAL_BLOCK)
进行内存的释放- 在语法层面上调用析构函数: 在释放内存之前调用对象的析构函数,以确保对象持有的资源(如动态分配的内存、打开的文件等)得到正确释放。
编译器在处理 delete obj;
这行代码时会生成以下等效的代码:
if (obj != nullptr) {obj->~A(); // 显式调用析构函数operator delete(obj); // 调用 operator delete 释放内存
}
new T[N] 与delete[]
new T[N]的原理
- 调用operator new[]函数,在operator new[]中实际调用operator new函数完成N个对
象空间的申请- 在申请的空间上执行N次构造函数
delete[]的原理
- 在释放的对象空间上执行N次析构函数,完成N个对象中资源的清理
- 调用operator delete[]释放空间,实际在operator delete[]中调用operator delete来释
放空间
定位new表达式(placement-new)
定位new表达式语法:void* operator new(size_t, void* place) noexcept { return place; }
- 定位new表达式(Placement New Expression),或简称placement new,是C++中一种特殊的内存分配式,它允许你在已经分配好的内存区域内构造对象。与标准的new操作符不同,定位new不负责内存的分配,而是直接在你指定的内存地址上调用对象的构造函数。这对于实现内存池、重复利用已分配的内存块、在特定内存位置(如共享内存)创建对象等场景非常有用。
- 定位
new
表达式允许我们在预分配的内存上构造对象,并手动管理对象的生命周期,包括调用析构函数和释放内存。这样可以更好地控制内存分配和释放过程,避免内存泄漏和资源未释放的问题。
如何使用
举例
#include <iostream>
#include <cstdlib> // for malloc and freeusing namespace std;class MyClass {
public:MyClass(int value) : value(value) {cout << "MyClass(int) constructor with value: " << value << endl;}~MyClass() {cout << "~MyClass() destructor with value: " << value << endl;}private:int value;
};int main() {// Step 1: Allocate raw memory using mallocsize_t numObjects = 3;void* rawMemory = malloc(numObjects * sizeof(MyClass));if (!rawMemory) {cerr << "Memory allocation failed!" << endl;return 1;}// Step 2: Use placement new to construct objects in the allocated memoryMyClass* objects = static_cast<MyClass*>(rawMemory);for (size_t i = 0; i < numObjects; ++i) {new (objects + i) MyClass(i * 10); // Construct MyClass objects with values 0, 10, 20}// Step 3: Use the objects (this step is trivial in this example)// Step 4: Manually call destructors for each objectfor (size_t i = 0; i < numObjects; ++i) {objects[i].~MyClass();}// Step 5: Free the allocated raw memoryfree(rawMemory);return 0;
}
步骤解析:
- 使用 malloc 分配原始内存:
size_t numObjects = 3;
void* rawMemory = malloc(numObjects * sizeof(MyClass));
if (!rawMemory) {cerr << "Memory allocation failed!" << endl;return 1;
}
- 使用
malloc
函数分配一块大小为numObjects * sizeof(MyClass)
的连续内存,用来存放 3 个MyClass
对象。- 如果内存分配失败,程序会输出错误信息并返回。
- 在分配的内存中,使用
new
构建对象:
MyClass* objects = static_cast<MyClass*>(rawMemory);
for (size_t i = 0; i < numObjects; ++i) {new (objects + i) MyClass(i * 10); // Construct MyClass objects with values 0, 10, 20
}
- 使用
placement new
表达式在预分配的内存上构造MyClass
对象。- 通过
static_cast
将rawMemory
转换为指向MyClass
类型的指针。- 在
for
循环中,调用定位new
在内存地址objects + i
上构造MyClass
对象,分别传入 0、10 和 20 作为构造函数参数。
-
对象的使用 (省略)
-
手动调用每个对象的析构函数进行析构
for (size_t i = 0; i < numObjects; ++i) {objects[i].~MyClass();
}
- 在内存释放之前,必须手动调用每个对象的析构函数,释放对象的资源。
- 使用
for
循环,调用每个对象的析构函数。
- 释放掉原始分配的内存
free(rawMemory);
使用
free
函数释放在步骤 1 中分配的原始内存。
注意事项
- 内存管理:使用
定位new
后,对象的生命周期管理完全由程序员负责。这意味着你不能使用普通delete
来释放这个对象,因为那会试图释放由malloc
分配的内存,导致未定义行为。你应该直接调用对象的析构函数,并手动归还内存:
A->~A(); // 手动调用析构函数
std::free(p1); // 释放内存
- 内存对齐:确保提供的内存地址是正确对齐的,以便能够容纳特定类型的对象。如果不对齐,可能导致未定义行为。
- 安全性:使用定位new时,你需要确保所指定的内存区域足够大,以容纳完整的对象实例,包括可能的内部对齐填充。否则,可能会覆盖周边内存,引发严重错误。
- 标准库支持:C++标准库提供了一个全局的
operator new(void*, std::size_t)
重载,它不执行任何实际的内存分配,专门用于定位new表达式。这个重载是固定的,不能被用户自定义版本替代。
malloc/free和new/delete的区别
malloc/free和new/delete的共同点是:
- 都是从堆上申请空间,并且需要用户手动释放。
不同的地方是:
malloc
和free
是函数,new
和delete
是操作符malloc
申请的空间不会初始化,new
可以初始化malloc
申请空间时,需要手动计算空间大小并传递,new
只需在其后跟上空间的类型即可,
如果是多个对象,[]
中指定对象个数即可- malloc的返回值为
void*
, 在使用时必须强转,new
不需要,因为new
后跟的是空间的类型- malloc申请空间失败时,返回的是
NULL
,因此使用时必须判空,new
不需要,但是new
需
要捕获异常- 申请自定义类型对象时,
malloc/free
只会开辟空间,不会调用构造函数与析构函数,而new
在申请空间后会调用构造函数完成对象的初始化,delete
在释放空间前会调用析构函数完成
空间中资源的清理释放