深入理解C++中的New和Delete并实现对象池

深入理解new和delete

new和delete称作运算符

1251189A-5FB7-00CE-6BFF-1BF6E2314FEE.png

我们转反汇编看看

6911628C-EE47-DA22-88F3-865CEC918B10.png

这2个运算符本质也是相应的运算符的重载的调用

malloc和new的区别?

1.malloc按字节开辟内存的;new开辟内存时需要指定类型 new int[10]

所以malloc开辟内存返回的都是void*

而new相当于运算符的重载函数 operator new ->返回值自动转成指定的类指针 int*

2.malloc只负责开辟空间,new不仅仅有malloc的功能,可以进行数据的初始化

new int(20);//初始化20  
new int[20]();//开辟数组是不支持初始化值的,但是支持写个空括号,表示给每个元素初始化为0 ,相当于每个元素调用int()成为0

3.malloc开辟内存失败返回nullptr指针;new抛出的是bad_alloc类型的异常

(也就是说,new运算符开辟内存失败,要把它的代码扩在try catch里面,是不能通过返回值和空指针比较的。)

try//可能发生错误的代码放在try里面 
	{
		int *p = new int;
		delete []p;

		int *q = new int[10];
		delete q;
	}
	catch (const bad_alloc &err)//捕获相应类型的异常 
	{
		cerr << err.what() << endl;//打印错误 
	}

2703B116-EAC3-7B64-4276-31B7E409D4CC.png

free和delete的区别?

delete p: 调用析构函数,然后再free( p),相当于包含了free

如果delete的是普通的指针,那么delete (int*)p和free( p)是没有区别的

因为对于整型指针来说,没有析构函数,只剩下内存的释放

new -> 对operator new重载函数的调用 
delete -> 对operator delete重载函数的调用

把new和delete的重载函数定义在全局的地方,这样我们整个项目工程中只有涉及到new和delete的地方都会调用到我们全局重写的new,delete的重载函数。

//先调用operator new开辟内存空间、然后调用对象的构造函数(初始化)
void* operator new(size_t size)
{
	void *p = malloc(size);
	if (p == nullptr)
		throw bad_alloc();
	cout << "operator new addr:" << p << endl;
	return p;
}
//delete p; 先调用p指向对象的析构函数、再调用operator delete释放内存空间
void operator delete(void *ptr)
{
	cout << "operator delete addr:" << ptr << endl;
	free(ptr);
}

7ECC8942-72D2-91C7-723F-E5093C75BF87.png

7E4F2DD2-91AD-65D5-A641-59908EDC8741.png

new和delete从内存管理的角度上来说和malloc和free没有什么区别

除非就是内存开辟失败,返回不一样

void* operator new[](size_t size)
{
	void *p = malloc(size);
	if (p == nullptr)
		throw bad_alloc();
	cout << "operator new[] addr:" << p << endl;
	return p;
}
void operator delete[](void *ptr)
{
	cout << "operator delete[] addr:" << ptr << endl;
	free(ptr);
}

780274EA-4737-2234-C69A-1DC51307461F.png

4E1F5774-BC3A-FFD9-6ECF-F989D049EE99.png

C++中,如何设计一个程序检测内存泄漏问题?

内存泄漏就是new操作没有对应的delete,我们可以在全局重写上面这些函数,在new操作里面用映射表记录都有哪些内存被开辟过,delete的时候把相应的内存资源删除掉,new和delete都有对应关系

如果整个系统运行完了,我们发现,映射表记录的一些内存还没有被释放,就存在内存泄漏了! 我们用new和delete接管整个应用的所有内存管理 ,对内存的开辟和释放都记录

也可以通过编译器既定的宏和API接口,把函数调用堆栈打印出来,到底在哪个源代码的哪一页的哪一行做了new操作没有delete

new和delete能混用吗?

C++为什么区分单个元素和数组的内存分配和释放呢?

下面这样操作是否可以???

EC47D85E-D7D6-6F3E-6EA2-9E0E93A620EA.png

其实现在对于整型来说,没有所谓的构造函数和析构函数可言,所以这样的代码就只剩下malloc和free的功能,所以底层调用的就是malloc和free

BD52B3E8-6623-E568-EF22-886F42BED29E.png

所以,它们现在混用是没有问题的!!!

那什么时候我们才需要考虑这些问题呢?

class Test
{
public:
	Test(int data = 10) { cout << "Test()" << endl; }
	~Test() { cout << "~Test()" << endl; }
private:
	int ma;
};

D2DE14CF-35A5-9F80-F31E-4BDEA56D9263.png

CDB8D02A-7F37-7954-64CA-C869CD189D8A.png

在这里面,我们能不能混用呢?

607C0BAB-ED72-DF7A-D93F-02E4FED6B030.png

3E620B24-7637-9A60-2E62-79C1B798AF3E.png

出现错误了。

此时new和delete不能进行混用了!

7009D58C-B29C-A410-33D2-146A32851729.png

67B63430-0FDF-96F1-1EE4-391D941D043B.png

C18C1E48-F377-EBE5-9E5F-2D11E0680BD6.png

在这里,new和delete可以混用吗?

1801D7CF-F0EA-C3AD-E303-3E174C0D479E.png

4701BF45-755A-008D-BDAF-3859F37403DF.png

运行出错了。

我们最好是这样配对使用:
new delete
new[] delete[]

对于普通的编译器内置类型

new/delete[]

new[]/delete

这样混用是可以的!

因为只涉及内存的开辟和释放,底层调用的就是malloc和free

但是,如果是对象,就不能混用了。

A268D6DD-BEC5-185C-DF0A-3C8C1EC50117.png

一个Test对象是4个字节。

每一个Test对象有1个整型的成员变量。

AB07F63D-D27D-D692-CB9C-60F4FB40E8EB.png

new的时候,分配了5个Test对象,但是不只是开辟了20个字节哦!

delete[]p2的时候先调用Test对象的析构函数,析构函数有this指针,this指针区分析构的对象,this指针把正确的对象的地址传到析构函数。现在加了[]表示有好几个对象,有一个数组,里面的每个对象都要析构,但是它是怎么知道是有5个对象呢???

所以,实际上,new Test[5]是开辟了如图式的内存:

多开辟了4个字节,存储对象的个数。

用户在写new Test[5]时,这个5是要被记录下来的。

而且,new操作完了之后,给以后返回的p2指针指向的地址是0x104这个地址!即数组首元素的地址。并不是真真正正底层开辟的0x100这个地址,因为那个是不需要让用户知道的,用户只需要知道这个指针指向的是第一个元素对象的地址。

45E7B66A-612A-0D3D-7C1E-14F070543D46.png

当我们去delete[]p2的时候,它一看这个[]就知道释放的是一个对象数组,那么就要从p2(0x104)上移4个字节,去取对象的个数,知道是5个对象了(一个对象是4字节),然后把ox104下的内存平均分成5份,每一份内存的起始地址就是对象的起始地址,然后传给对象的析构函数,就可以进行对象的析构了。然后进行内存的释放,operator delete(p2-4),从0x100开始释放!!!

BA9F3B4B-DEBB-D017-B1B0-C42E564B1D5C.png

9503BDDB-42BF-E294-3575-BBFA687A4AF4.png

这个代码错误在:实际上开辟的内存空间大小是20+4=24字节,开辟内存是从0028开辟的,因为它有析构函数,所以在底层给数组开辟内存时多开辟了4个字节来存储开辟的对象的个数,但是用户返回的是02c,比028刚好多了4个字节,也就是给用户返回的是真真正正对象的起始地址。

delete p2;它就认为p2只是指向1个对象,因为没有使用delete[],所以它就只是把Test[0]这个对象析构了而已,然后直接free(p2),从第一个对象的地址(02c)开始free,而底层内存是从028开始开辟的。

我们换成delete[]p2,来运行看看

3CCC999E-3C75-159D-5337-4F0661230BFB.png

从指针-4开始free释放内存的操作

607C0BAB-ED72-DF7A-D93F-02E4FED6B030.png

这个代码的出错在:只是new出来1个对象,在0x104开辟的,p1也是指向了0x104,但是在delete[]的时候,认为是指向的是对象数组,因为还有析构函数,于是它就从0x104上移4个字节去取开辟对象的个数,B4972E8F-D4FA-D8CD-66D0-2501C608CF6C.png

这就出现了问题了。

关键是它free的时候,执行的是free(0x104-4)

但是new的时候并不是从0x100开始开辟内存的。

自定义的类类型,有析构函数,为了调用正确的析构函数,那么开辟对象数组的时候,会多开辟4个字节,记录对象的个数

对象池代码应用

对象池的实现是静态链表,在堆上开辟的。

85FB4BF9-D772-0AB0-E440-B7DF5D169298.png

E5A85175-0CC9-1C5C-8836-3EC8DF1FA1EC.png

8EEDB50B-964B-EABC-798D-2F56E35327EF.png

#include <iostream>
using namespace std;

template<typename T>
class Queue
{
public:
	Queue()//构造函数 0构造(默认构造) 
	{
		_front = _rear = new QueueItem();
	}
	~Queue()//析构函数 
	{
		QueueItem *cur = _front;//指向头结点 
		while (cur != nullptr)
		{
			_front = _front->_next;
			delete cur;
			cur = _front;
		}
	}
	void push(const T &val)//入队操作
	{
		QueueItem *item = new QueueItem(val);//malloc
		_rear->_next = item;
		_rear = item;
	}
	void pop()//出队操作 队头出 头删法 
	{
		if (empty())
			return;
		QueueItem *first = _front->_next;
		_front->_next = first->_next;
		if (_front->_next == nullptr)//队列原本只有1个有效元素节点 
		{
			_rear = _front;
		}
		delete first;//free
	}
	T front()const//获取首元素的值 
	{
		return _front->_next->_data;
	}
	bool empty()const { return _front == _rear; }//判空  链式队列 
private:
	//产生一个QueueItem的对象池(10000个QueueItem节点)
	struct QueueItem//节点类型,链式队列,带头节点的单链表 
	{
		QueueItem(T data = T()) :_data(data), _next(nullptr) {}//构造函数
		 
		//给QueueItem提供自定义内存管理
		void* operator new(size_t size)
		{
			if (_itemPool == nullptr)//如果对象池满了,对象池的指针就指向空了,然后现在进入,再开辟一个对象池 
			{
				_itemPool = (QueueItem*)new char[POOL_ITEM_SIZE*sizeof(QueueItem)];//开辟池 
				QueueItem *p = _itemPool;
				for (; p < _itemPool + POOL_ITEM_SIZE - 1; ++p)//连在一个链表上 
				{
					p->_next = p + 1;//因为节点内存是连续开辟的 可以用p+1 
				}
				p->_next = nullptr;
			}

			QueueItem *p = _itemPool;
			_itemPool = _itemPool->_next;
			return p;
		}
		void operator delete(void *ptr)
		{
			QueueItem *p = (QueueItem*)ptr;
			p->_next = _itemPool;
			_itemPool = p;//往头前放,然后连起来 
		}
		T _data;//数据域 
		QueueItem *_next;//指向下一个节点的指针域 
		static QueueItem *_itemPool;//指向对象池的起始地址,因为所有的 QueueItem都放在一个对象池里面 
		static const int POOL_ITEM_SIZE = 100000;//开辟的对象池的节点的个数,静态常量可以直接在类体初始化 
	};

	QueueItem *_front;//指向头节点
	QueueItem *_rear;//指向队尾 即链表的最后一个元素 
};

template<typename T>//在类外定义静态成员变量 
typename Queue<T>::QueueItem *Queue<T>::QueueItem::_itemPool = nullptr;
//typename告诉编译器后边的嵌套类作用域下的名字是类型,放心使用吧 

int main()
{
	Queue<int> que;
	for (int i = 0; i < 1000000; ++i)
	{
		que.push(i);//QueueItem(i)
		que.pop();//QueueItem
	}
	cout << que.empty() << endl;

	return 0;
}

可以把指针改为智能指针,出作用域,对象池自动释放

收藏 (0)
评论列表
正在载入评论列表...
我是有底线的
为您推荐
    暂时没有数据