文章目录

内存分布内存分布图解

C语言中动态内存管理方式malloc:callocrealloc

C++内存管理方式内置类型**自定义类型**

operator new & operator deleteoperator new & operator delete函数operator newoperator delete

**new T[N]** 与**delete[]**

**定位new表达式(placement-new)**如何使用注意事项

malloc/free和new/delete的区别

类和对象三部曲：

[C++] 轻熟类和对象

[C++] 由浅入深理解面向对象思想的组成模块

类和对象：C++11新特性与知识补充

内存分布

内存分布图解

栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口

创建共享共享内存，做进程间通信。堆用于程序运行时动态内存分配，堆是可以上增长的。数据段–存储全局数据和静态数据。代码段–可执行的代码/只读常量

C语言中动态内存管理方式

malloc:

<code>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++内存管理方式

内置类型

<code>// 动态申请一个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操作符，申请和释放连续的空间，使用<code>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

原理：

**内置类型：**与<code>malloc相似自定义类型：

调用operator new函数申请空间在申请的空间上执行构造函数，完成对象的构造

源码如下

/*

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) // 通过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_FINALLY

return;

}

/*

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表达式语法：<code>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 free

using 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 malloc

size_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 memory

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

}

// Step 3: Use the objects (this step is trivial in this example)

// Step 4: Manually call destructors for each object

for (size_t i = 0; i < numObjects; ++i) {

objects[i].~MyClass();

}

// Step 5: Free the allocated raw memory

free(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的共同点是:

都是从堆上申请空间，并且需要用户手动释放。

---

不同的地方是：

<code>malloc和free是函数，new和delete是操作符malloc申请的空间不会初始化，new可以初始化malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，

如果是多个对象，[]中指定对象个数即可malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需

要捕获异常申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new

在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成

空间中资源的清理释放