从入门到精通C++（动态内存管理）

用户11305458

发布于 2024-10-09 16:23:28

18000

代码可运行

文章被收录于专栏：学习学习

运行总次数：0

代码可运行

C语言的动态内存管理

在C语言中用malloc和realloc还有colloc，来进行动态内存管理，三个函数的用处分别为： malloc：开辟一个新的空间，不对空间进行初始化和任何操作 **realloc：realloc() 函数用于重新分配之前通过 malloc()、calloc() 或 realloc() 分配的内存块的大小。它允许你在运行时改变内存块的大小。具体来说，realloc() 可以用来扩大或缩小内存块的大小，注意如果想扩容的空间还没有开辟空间，那么realloc的用法就等价于malloc。 calloc：calloc和malloc类似，但是calloc比malloc多一个步骤，就是初始化。

空间开辟好之后，就需要进行释放，C语言中对应的释放的函数是free()。

	int* p1 = (int*)malloc(sizeof(int) * 10);//开辟十个int类型的空间
	int* p2 = (int*)calloc(1, sizeof(int) * 10);//开辟十个空间并且将p1初始化为1
	int* tmp = (int*)realloc(p1, sizeof(int) * 5);//扩容开辟五个空间
	tmp = p1;
	free(p1);
	free(p2);

C++的动态内存管理

C语言中的动态内存管理在C++中可以继续使用，但是C++中有自己的动态内存管理模式，在C语言中动态内存管理是函数，在C++中动态内存管理是操作符，对应的C++的动态内存管理是new，delete

C++中开辟一个空间和开辟十个空间：

int main()
{
	//开辟一个int类型的空间
	int* p1 = new int;
	//开辟十个空间
	int* p2 = new int[10];
	return 0;
}

C语言中的malloc不支持初始化，但是C++中支持初始化，对于内置类型C++的好处不大，但是对于内置类型C++中的new就展现出了很大的优势 C++中的初始化：

int main()
{
	//开辟一个int类型的空间
	int* p1 = new int(1);
	int* p2 = new int[10] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	cout << *p1 << endl;
	for (int i = 0;i < 10;i++)
	{
		cout << p2[i] << " ";
	}
	delete[] p2;
	delete p1;
	return 0;
}

对于自定义类型，如果在C++中成员变量是私有的，我们就不能像C语言那样直接用成员变量初始化了，如果还继续沿用C语言中的malloc不利于初始化，如果我们用new的话，可以直接调用构造函数进行初始化。 我们先创造一个类叫A

class A
{
public:
	A(int a = 0)
		:_a1(a)
		,_a2(nullptr)
	{}
private:
	int* _a2;
	int _a1;
};

int main()
{
	A* p1 = new A(1);//隐式类型转换，并且调用构造函数和拷贝构造函数
	A* p2 = new A[10]{ 1,2,3,4 };
	delete[] p2;
	delete p1;
}

对于自定义类型new就占有很多的优势，在创建对象的时候，可以直接调用构造函数，并且进行隐式类型转换，如果创建的是多个对象的话，可以在后面加上花括号，在花括号进行初始化 多参数的默认构造函数如何初始化？

class A
{
public:
	A(int a = 0, int b = 0)
		:_a1(a)
		,_a2(nullptr)
	{}
private:
	int* _a2;
	int _a1;
};

int main()
{
	A* p3 = new A[10]{ {1,2},{2,3},1,2,3 };
	delete[] p3;
}

对于多参数的默认构造函数的初始化只需要在内部加上花括号，将多个参数包含在内即可

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)
{
// 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来释放空间的。 底层本质：

new的底层其实是operator new+构造函数，operator new的底层其实是malloc+抛出异常 delete的底层其实是operator delete+析构函数，operator delete的底层其实是free

operator new和operator delete的底层是malloc和free进行封装的结果。