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

2024-10-09 16:23:28 浏览数 (4)

C语言的动态内存管理

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

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

代码语言：javascript复制
	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 中开辟一个空间和开辟十个空间：

代码语言：javascript复制
int main()
{
	//开辟一个int类型的空间
	int* p1 = new int;
	//开辟十个空间
	int* p2 = new int[10];
	return 0;
}

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

代码语言：javascript复制
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

代码语言：javascript复制
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就占有很多的优势，在创建对象的时候，可以直接调用构造函数，并且进行隐式类型转换，如果创建的是多个对象的话，可以在后面加上花括号，在花括号进行初始化 多参数的默认构造函数如何初始化？

代码语言：javascript复制
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全局函数来释放空间。

代码语言：javascript复制
/*
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进行封装的结果。

总结

在C 中，动态内存管理是一项强大而又易于出错的功能。通过使用new和delete或者更现代化的智能指针，我们可以在程序运行时分配和释放内存。然而，这种灵活性也伴随着责任，需要我们谨慎地管理内存，以避免内存泄漏和悬空指针等问题。在编写C 程序时，应该始终牢记内存管理的原则：

  1. 合理使用动态内存分配：只在必要时才使用动态内存分配，尽量避免内存分配与释放频繁发生，以提高程序效率和性能。
  2. 记得释放已分配的内存：每次通过new分配内存后，都要确保在不再需要该内存时通过delete或智能指针等方式释放它，避免内存泄漏问题。
  3. 避免悬空指针：当指针指向的内存被释放后，及时将指针置为nullptr或者使用智能指针，避免产生悬空指针引发的未定义行为。
  4. 考虑异常安全性：在使用动态内存管理时，需要考虑异常安全性，确保在发生异常时不会造成内存泄漏或数据损坏。
  5. 通过遵循这些原则，我们可以更加安全和高效地使用C 的动态内存管理功能，确保我们的程序在运行时能够稳定可靠地执行。
c++ 函数 内存 内存管理 入门

0 人点赞