深度剖析C++的new、delete和placement new

---

前言

推荐一个网站给想要了解或者学习人工智能知识的读者，这个网站里内容讲解通俗易懂且风趣幽默，对我帮助很大。我想与大家分享这个宝藏网站，请点击下方链接查看。
https://www.captainbed.cn/f1
new、delete 和 placement new 是 C++ 中的内存管理操作符。

• new：用于在堆上动态分配内存并初始化对象。它返回指向新创建对象的指针。如果内存分配失败，new 会抛出一个 std::bad_alloc 异常。
• delete：用于释放之前由 new 分配的内存。它接受一个指针，并释放该指针指向的内存。如果传递给 delete 的指针是 nullptr，则不执行任何操作。
• placement new：是一种低级的内存分配机制，允许在已经分配的内存上构造对象。它接受一个指向内存的指针，并在该内存上构造一个对象。placement new 不会分配新的内存，而是使用已经存在的内存。

总的来说，new 和 delete 是 C++ 中用于动态内存管理的标准操作符，而 placement new 则提供了一种更底层的内存管理方式，允许在特定内存地址上构造对象。

---

一、new和delete的实现原理

内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

自定义类型

new的原理

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

delete的原理

• 在空间上执行析构函数，完成对象中资源的清理工作
• 调用operator 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表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

使用格式

new (place_address) type或者new (place_address) type(initializer-list)
1

place_address必须是一个指针，initializer-list是类型的初始化列表

示例

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}

	~A()
	{
		cout << "~A():" << this << endl;
	}

private:
	int _a;
};

// 定位new/replacement new
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();
	free(p1);


	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

使用场景

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

示例

下面是一个使用定位new从内存池分配内存并进行初始化的示例：

#include <iostream>

// 自定义的内存池类
class MemoryPool {
private:
    char* memory;
    size_t size;

public:
    MemoryPool(size_t size) : size(size) {
        memory = new char[size];
    }

    ~MemoryPool() {
        delete[] memory;
    }

    void* allocate(size_t size) {
        // 在内存池中分配size大小的内存，并返回指针
        return memory;
    }
};

// 自定义的类
class MyClass {
private:
    int value;

public:
    MyClass(int value) : value(value) {}

    void display() {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    // 创建一个内存池对象，大小为sizeof(MyClass)
    MemoryPool pool(sizeof(MyClass));

    // 从内存池中分配内存
    void* memory = pool.allocate(sizeof(MyClass));

    // 使用定位new在分配的内存上构造MyClass对象
    MyClass* obj = new (memory) MyClass(42);

    // 对象已经在内存池中初始化完成，可以直接使用
    obj->display();

    // 显式调用析构函数来销毁对象
    obj->~MyClass();

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

在上面的示例中，我们首先创建了一个自定义的内存池类MemoryPool，用于管理一块固定大小的内存。然后，我们在main函数中创建了一个内存池对象pool，并通过调用allocate方法从内存池中分配一块大小为sizeof(MyClass)的内存。

接下来，我们使用定位new语法new (memory) MyClass(42)在分配的内存上构造了一个MyClass对象。由于我们手动分配了内存，并调用了定位new来构造对象，所以对象的内存是从内存池中分配的。

最后，我们通过调用析构函数obj->~MyClass()来显式地销毁对象，释放内存。在实际应用中，我们需要在不再使用对象时手动调用析构函数来销毁对象，以确保内存的正确释放。

池化技术

池化技术是一种常用的深度学习技术，用于减少输入数据的尺寸和参数数量，以降低计算复杂度并提高模型的泛化能力。

池化技术主要有两种类型：最大池化和平均池化。最大池化是从输入数据中选取最大值作为输出，而平均池化是计算输入数据的平均值作为输出。这些操作可以在二维数据（如图像）或多维数据（如文本）上进行。

池化技术的作用是通过保留数据的主要特征来减少输入数据的尺寸。通过降低数据的维度，网络能够更好地处理输入数据，并且具有更强大的泛化能力。此外，池化技术还能够增加模型的平移不变性，即对输入数据的平移具有不变性，因为最大或平均值不受平移的影响。

池化技术通常与卷积神经网络（CNN）结合使用，用于处理图像和语音等数据。在CNN中，卷积层用于提取特征，而池化层用于降低特征图的尺寸和参数数量。这样可以减少计算复杂度，使网络能够更快地训练和推理。

总之，池化技术是深度学习中常用的技术之一，用于减少输入数据的尺寸和参数数量，并提高模型的泛化能力和计算效率。

内存池

内存池（Memory Pool）是一种用于管理内存分配和回收的技术。它通过预先分配一定大小的连续内存块，并以固定大小的块来进行分配和回收，以避免频繁的内存分配和释放操作带来的性能损耗。

内存池通常由两部分组成：内存分配器和内存管理器。内存分配器负责分配内存块，而内存管理器负责管理已分配的内存块和回收不再使用的内存块。

内存池的主要优点包括：

1. 提高内存分配和回收的效率：内存池预先分配了一定大小的内存空间，避免了频繁的内存分配和回收操作，提高了内存的利用率和系统的性能。
2. 减少内存碎片：内存池使用固定大小的内存块进行分配和回收，避免了因为多次内存分配和释放而导致的内存碎片问题。
3. 简化内存管理：内存池提供了简单而高效的内存管理接口，减少了内存管理的复杂性和开销。

内存池适用于需要频繁进行内存分配和释放的场景，如网络编程中的连接池、数据库连接池等。它可以提高系统的性能和稳定性，减少资源的消耗和浪费。

三、常见例题

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在释放空间前会调用析构函数完成空间中资源的清理

内存泄漏

什么是内存泄漏

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄露危害

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;

	// 2.异常安全问题
	int* p3 = new int[10];

	Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.

	delete[] p3;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏

堆内存泄漏(Heap leak)

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

如何检测内存泄漏

在vs下，可以使用windows操作系统提供的_CrtDumpMemoryLeaks() 函数进行简单检测，该函数只报出了大概泄漏了多少个字节，没有其他更准确的位置信息。

void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;

	// 2.异常安全问题
	int* p3 = new int[10];

	Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.

	delete[] p3;
}

//
int main()
{
	int* p = new int[10];

	// 将该函数放在main函数之后，每次程序退出的时候就会检测是否存在内存泄漏
	_CrtDumpMemoryLeaks();
	return 0;
}


// 程序退出后，在输出窗口中可以检测到泄漏了多少字节，但是没有具体的位置
Detected memory leaks!
Dumping objects ->
{79} normal block at 0x00EC5FB8, 40 bytes long.
Data: < > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
Object dump complete.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

因此写代码时一定要小心，尤其是动态内存操作时，一定要记着释放。但有些情况下总是防不胜防，简单的可以采用上述方式快速定位下。如果工程比较大，内存泄漏位置比较多，不太好查时一般都是借助第三方内存泄漏检测工具处理的。

• 在linux下内存泄漏检测
• 在windows下使用第三方工具
• 其他工具

如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

总结一下:
内存泄漏非常常见，解决方案分为两种：

1. 事前预防型。如智能指针等。
2. 事后查错型。如泄漏检测工具。

---