【浅谈 new 与 delete】

2023-11-16

前言

打怪升级：第39天

在C语言中，我们动态申请内存的方法是使用malloc函数，它的同胞兄弟还有calloc 和realloc，
与它们配套使用的释放内存的操作为free函数；
因为c++是兼容c的，所以这些函数在c++中是同样可以使用的，那既然如此，
c++为何还要大费周章地去再增添两个新的操作符来完成“原本就可以完成的工作”呢？

C语言是一个面向过程的语言，而c++虽然脱胎与c语言，但它是属于面向对象的，虽然有相同之处，但是c++相对C语言又添加
了太多的新内容，而C语言之中的一些东西虽然可以用，但是已经无法满足我们的使用需求，因此，c++又引入了new 和 delete 两个新的操作符来进行动态内存管理。

new 与 delete

内置类型

new使用示例

	//	内置类型
void Test01()
{
	int* p1 = new int;  // 动态申请1个int的空间

	int* p2 = new int(10);  // 动态申请1个int的空间 ， 并初始化为 10

	int* p3 = new int[5];  // 动态申请10个int的空间 - 数组

	int* p4 = new int[5] { 0 }; // 动态申请10个int的空间， 并且全部初始化为 0 


	//  注意看new的使用语法，
}

delete使用示例

//	内置类型
void Test01()
{
	int* p1 = new int;  // 动态申请1个int的空间

	delete p1;       //  释放一个空间

	int* p3 = new int[5];  // 动态申请10个int的空间 - 数组

	delete[] p3;     //   释放一个数组

}

new 和 malloc 对比

//	new  和  malloc对比

void Test01()
{
	int* p1 = new int;  
	delete p1;     

	int* p2 = (int*)malloc(sizeof(int));
	free(p2);
	

	int* p3 = new int[5];  
	delete[] p3;    

	int* p4 = (int*)malloc(sizeof(int) * 5);
	free(p4);
}

new初始化

void Test01()
{
	int* p1 = new int(10);  

	int* p2 = (int*)malloc(sizeof(int));
	

	int* p3 = new int[5] { 1, 2 };  

	int* p4 = (int*)malloc(sizeof(int) * 5);
}

自定义类型

在上面我们可以发现，对于自定义类型的申请空间 new和malloc的差别并不算大，也就是new在写法上方便一些，
而如果仅仅是为了方便一点点就去写出一个新的操作符未免有些大材小用了，
new和malloc真正的区别在于对自定义类型数据申请空间上：

class Date
{
public:
	Date(int year = 2023, int month = 3, int day = 11)
		:_year(year)
		,_month(month)
		,_day(day)
	{}

private:
	int _year;
	int _month;
	int _day;
};

void Test02()
{
	Date* p1 = new Date;

	Date* p2 = (Date*)malloc(sizeof(Date));
	
	delete(p1);
	free(p2);
}

我们继续看下面一个例子：

class Stack
{
public:
	Stack(int capacity = 8)
	{
		cout << "Stack(int)" << endl;

		_a = new int[capacity] {0};
		_size = 0;
		_capacity = capacity;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;

		delete[] _a;
		_a = nullptr;
		_size = _capacity = 0;
	}

private:
	int* _a;
	int _size;
	int _capacity;

};

void Test03()
{
	Stack* p1 = new Stack;

	Stack* p2 = (Stack*)malloc(sizeof(Stack));

	delete p1;
	free(p2);

}

在这里插入图片描述

new 和 delete 自动调用默认构造和析构函数。

因此我们要注意：new 和 malloc 最大的区别就是： new 和 delete会自动调用自定义类型的默认构造和析构函数，malloc 和 free 不会。

operator new 与 operator delete

new 和 delete 是用户进行动态内存申请和释放的操作符，
operator new 和 operator delete 是系统提供的全局函数，
new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

 //  下方是截取的 operator new、 operator delete源码，我们把注释理解一下即可。

/*
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)
  if (_callnewh(size) == 0)
     {
         // report no memory
         // 如果申请内存失败了，这里会抛出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);  /* block other threads */
     __TRY
         /* get a pointer to memory block header */
         pHead = pHdr(pUserData);
          /* verify block type */
         _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
         _free_dbg( pUserData, pHead->nBlockUse );
     __FINALLY
         _munlock(_HEAP_LOCK);  /* release other threads */
     __END_TRY_FINALLY
     return;
}
/*
free的实现
*/
#define   free(p)               _free_dbg(p, _NORMAL_BLOCK)

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

补充： operator new 和 operator delete函数 并不是重载 new 和 delete运算符，只是！只是“碰巧”取了这么个名字罢了，
至于为什么取的这么个具有误导性的名字，只有“天知道”，可能是由于外国人起名字的一种习惯，也可能是当时编写该函数的大佬的恶趣味罢，这里可是“绊倒了”一批又一批的c++学子，那么我们现在知道它们不是运算符重载即可。

new 和 delete 实现原理

内置类型

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

自定义类型

new的原理

调用operator new函数申请空间，operator new 内部使用 malloc；

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

delete的原理

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

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

new T[N]的原理

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

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

delete[]的原理

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

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

定位new

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

使用格式：
new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，
需要使用new的定位表达式进行显示调构造函数进行初始化。

class A
{
public:
	A(int a = 10)
		: _a(a)
	{}

	~A()
	{}

private:
	int _a;
};

void Test04()
{
	A* p1 = new A;

	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A;

	A* p3 = (A*)malloc(sizeof(A));// p3现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	new(p3)A;                    //  定位new会去调用自定义类型的构造函数

	A* p4 = (A*)malloc(sizeof(A));

}

在这里插入图片描述

总结

没有太多需要注意的，大家一定一定配对使用。

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)