C++中的new和delete

kazamata

于 2024-07-15 14:38:33 发布

阅读量850

点赞数 19

分类专栏： C++ 文章标签： c++ 笔记学习 visual studio c语言

本文链接：https://blog.csdn.net/2301_80909286/article/details/140432928

版权

C++ 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

C++相较于C语言，引入了一种新的动态内存管理的方式，即new和delete操作符。不过C语言中的malloc、calloc、realloc以及free函数在C++中都能够使用，那么为什么C++还要引入新的动态内存管理的方法呢？

回顾malloc/calloc/realloc和free的用法

它们是C语言stdlib.h库中的函数，起到在堆上开辟和释放空间的作用。

#include <cstdlib> // cpp
// #include <stdlib.h> // c

int main()
{
	int* p1 = (int*)malloc(sizeof(int)); // 申请1个int类型的空间
	int* p2 = (int*)malloc(sizeof(int) * 10); // 申请10个int类型的空间
	free(p1); // 回收p1指向的空间
	free(p2); // 回收p2指向的空间

	int* p3 = (int*)calloc(4, sizeof(int)); // 申请4个int类型的空间，并把这些空间初始化为0
	int* p4 = (int*)realloc(p3, sizeof(int) * 100); // 将p3指向的空间扩容成100个int类型

	free(p4); // 这里不需要free(p3) 因为在realloc的时候就已经释放了p3
	return 0;
}

注：这里我并没有对realloc详细介绍，其实realloc对堆空间的重分配更加复杂，如果你想详细了解一下它的工作原理，可以自行搜索相关内容学习。

这里给出malloc的实现原理：glibc中malloc的实现原理

new和delete

回顾完我们在C语言中经常接触到的好朋友后，我们就要迎来我们在C++中的新朋友。为了方便，下文主要是比较new和malloc，delete和free。现在让我们来看看，C++中为什么要引入这两个新操作符。

对内置类型

对于内置类型如int、double、char等类型来说，malloc和new、free和delete几乎没有区别。

#include <iostream>
using namespace std;

int main() 
{
	// 开单个空间
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;

	// 开数组（连续）空间
	int* p3 = (int*)malloc(sizeof(int) * 5);
	int* p4 = new int[5];


	free(p1);
	delete p2;
	free(p3);
	delete[] p4;
}

这里需要注意的是：申请和释放单个元素的空间，使用new和delete操作符；申请和释放连续的空间，使用new[]和delete[]。

如果实在要说new和malloc有什么不同，那就是new有了calloc的功能即能够初始化申请的空间，并且初始化的功能更加强大。

#include <iostream>
#include <cassert>
using namespace std;

int main() 
{
	int* p1 = new int(10); // 申请1个int的空间，并初始化为10

	int* p2 = new int[5] {1, 2, 3, 4, 5}; // 申请5个int的空间，分别初始化为1、2、3、4、5
	int* p3 = (int*)calloc(5, sizeof(int)); // 申请5个int的空间，全部初始化为0
	assert(p3); // 确保p3不为空指针

	cout << *p1 << endl;

	cout << "p2: ";
	for (int i = 0; i < 5; ++i) {
		cout << p2[i] << " ";
	}
	cout << endl;

	cout << "p3: ";
	for (int i = 0; i < 5; ++i) {
		cout << p3[i] << " ";
	}
	cout << endl;

	delete p1;
    delete[] p2;
	free(p3);

	return 0;
}

对自定义类型

对struct、class、std::string、std::pair等自定义类型而言，new和malloc、delete和free就有很大的区别了。

#include <iostream>
#include <cassert>
using namespace std;

struct Test
{
	Test() : data_(520)
	{
		cout << "Test()" << endl;
	}

	~Test()
	{
		cout << "~Test()" << endl;
	}

	int data_;
};

int main()
{
	cout << "malloc/free:" << endl;
	Test* test1 = (Test*)malloc(sizeof(Test));
	assert(test1);
	cout << test1->data_ << endl;
	free(test1);

	cout << endl;
	cout << "---------------------------";
	cout << endl;

	cout << "new/delete:" << endl;
	Test* test2 = new Test();
	cout << test2->data_ << endl;
	delete test2;

	return 0;
}

从结果中我们可以看出来，new会在申请空间之后调用自定义类型对象的构造函数来初始化对象，而delete会在释放空间之前调用自定义类型对象的析构函数来释放对象中的资源，但是malloc和free就没有这种功能。

所以对自定义类型而言，new的功能为申请空间+调用对象构造函数初始化，delete为调用对象析构函数释放资源+释放空间。

C++作为一门面向对象的语言，new和delete的出现使程序员能够更加方便地管理动态内存。

所以相较于malloc和free，现在更加推荐new和delete。

new和delete的实现原理

现在，我们对new和delete的用法有了相对清楚的了解。那么你有没有想过，new和delete是如何做到在管理空间的同时完成对对象资源的初始化和释放。其实为了完成这项工作，还需要借助operator new与operator delete函数。

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) // 异常声明，声明该函数可能抛出bad_alloc异常
{
    // 尝试申请size字节大小的空间
	void* p;
	while ((p = malloc(size)) == 0)
        if (_callnewh(size) == 0)
        {
            // 如果申请内存失败了，这里会抛出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);
    __FINALLY
        _munlock(_HEAP_LOCK); // 释放其他线程
    __END_TRY_FINALLY
        return;
}

// free的实现
#define   free(p)               _free_dbg(p, _NORMAL_BLOCK)

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果 malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 也是通过free来释放空间的。

operator new与malloc、operator delete与free在使用上没有任何区别，只有处理错误的方式不一样。

#include <iostream>
using namespace std;

int main()
{
	size_t size = 128; // 防止整形溢出
	void* p1 = malloc(size * 1024 * 1024 * 1024); // 申请128G的内存空间
	cout << p1 << endl; // 如果没申请到p1就为空指针
	if (p1) free(p1); // 如果申请到了则释放空间

	try
	{
		void* p2 = operator new(size * 1024 * 1024 * 1024); // 申请128G的内存空间
		cout << p2 << endl; // 如果没申请到就会抛异常，就不会执行该语句及之后的语句
		operator delete(p2); // 释放p2指向的空间
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

因为有异常的关系，所以new不需要像malloc一样通过返回值来判断是否申请空间成功，当new申请空间失败是会直接抛出异常，如果不处理异常，程序就会终止。

现在我们知道new和delete会调用全局的operator new和operator delete函数，但其实我们可以在类中自定义这两个函数来定制专属的new和delete，这样的话在new和delete这个类的对象时，就不会调用全局的函数，而是调用自定义的函数。

#include <iostream>
using namespace std;

struct ListNode
{
	ListNode* prev_;
	ListNode* next_;
	int data_;

	void* operator new(size_t size)
	{
		void* p = nullptr;

		// 假装这里是在内存池中申请空间的逻辑...
		p = allocator<ListNode>().allocate(1);
		cout << "内存池分配空间" << endl;

		return p;
	}

	void operator delete(void* p)
	{
		// 假装这里是在内存池中回收空间的逻辑...
		allocator<ListNode>().deallocate((ListNode*)p, 1);

		cout << "内存池回收空间" << endl;
	}
};

int main()
{
	ListNode* node = new ListNode();
	delete node;
	return 0;
}

我们就可以通过定制的方式来完成内存池的相关逻辑。

总结

内置类型

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

自定义类型

new的原理：

1. 调用operator new函数申请空间

2. 在申请的空间上执行构造函数，完成对象的构造

delete的原理：

1. 在空间上执行析构函数，完成对象中资源的清理工作

2. 调用operator delete函数释放对象的空间

new T[N]的原理：

1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请

2. 在申请的空间上执行N次构造函数

delete[]的原理：

1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理

2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

定位new表达式(placement-new)

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

使用格式： new (place_address) type或者new (place_address) type(initializer-list)，其中place_address必须是一个指针，initializer-list是类型的初始化列表。

有了定位new表达式后，我们就能模拟出new的功能了

#include <iostream>
using namespace std;

struct Test
{
	Test(int data) :data_(data)
	{
		cout << "Test()" << endl;
	}
	~Test()
	{
		cout << "~Test()" << endl;
	}

	int data_;
};

int main()
{
	cout << "new/delete:" << endl;
	Test* t1 = new Test(1234);
	cout << t1->data_ << endl;
	delete t1;

	cout << endl;
	cout << "-----------------------" << endl;
	cout << endl;

	cout << "my new/delete:" << endl;
	Test* t2 = (Test*)operator new(sizeof(Test));
	cout << "operator new end" << endl;
	new (t2) Test(5678);
	cout << "placement-new end" << endl;
	cout << t2->data_ << endl;
	t2->~Test();
	operator delete(t2);

	return 0;
}

从输出结果中可以看出，确实是通过定位new表达式调用了对象的构造函数。

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

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

注意事项

不可一个delete后跟多个对象

#include <iostream>
using namespace std;

struct Test
{
	Test(int data) :data_(data)
	{
		cout << "Test()" << endl;
	}
	~Test()
	{
		cout << "~Test() -> " << data_ << endl;
	}

	int data_;
};

int main()
{
	Test* t1 = new Test(1);
	Test* t2 = new Test(2);

	delete t1, t2; // error! 只会delete t1

	Test* t3 = new Test(3);
	Test* t4 = new Test(4);

    // (t3, t4)为逗号表达式，表达式的结果为t4，所以下面的语句相当于delete t4;
	delete (t3, t4); // error! 只会delete t4

	return 0;
}

因为C++没有GC（垃圾回收）机制的原因，我们每new一个对象就要自己手动delete一个对象，有的人为了偷懒，就会把多个delete省略成一个delete，但其实这样是不对的，一个delete语句只会delete的一个对象，其余对象不会被delete，如果就这样放着不管，就会造成内存泄漏。

内存泄漏

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了该段内存的控制，因而造成了内存的浪费。长期运行的程序出现内存泄漏，对程序的运行影响很大，如操作系统、后台服务等出现内存泄漏会导致响应越来越慢，最终卡死。

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

堆内存泄漏(Heap leak)

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

系统资源泄漏

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

那么如何如何避免内存泄漏呢？

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。

2. 采用RAII思想或者智能指针来管理资源。

3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。

4. 出问题了使用内存泄漏工具检测。

总结一下: 内存泄漏非常常见，解决方案分为两种：1、事前预防型，如智能指针等。2、事后查错型，如泄漏检测工具。

内存泄漏检测工具介绍：