C/C++内存管理

嘉城401

已于 2023-08-27 09:12:20 修改

阅读量56

点赞数

文章标签： c语言 c++

于 2023-08-23 00:26:20 首次发布

本文链接：https://blog.csdn.net/qq_75132460/article/details/132405667

版权

文章目录

1.C/C++内存分布

我们先来看下面的一段代码和相关问题

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
 static int staticVar = 1;
 int localVar = 1;
 int num1[10] = { 1, 2, 3, 4 };
 char char2[] = "abcd";
 const char* pChar3 = "abcd";
 int* ptr1 = (int*)malloc(sizeof(int) * 4);
 int* ptr2 = (int*)calloc(4, sizeof(int));
 int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
 free(ptr1);
 free(ptr3);
}
1. 选择题：
   选项: A.栈  B.堆  C.数据段(静态区)  D.代码段(常量区)
   globalVar在哪里？____   staticGlobalVar在哪里？____
   staticVar在哪里？____   localVar在哪里？____
   num1 在哪里？____
   
   char2在哪里？____   *char2在哪里？___
   pChar3在哪里？____      *pChar3在哪里？____
   ptr1在哪里？____        *ptr1在哪里？____
2. 填空题：
   sizeof(num1) = ____; 
   sizeof(char2) = ____;      strlen(char2) = ____;
   sizeof(pChar3) = ____;     strlen(pChar3) = ____;
   sizeof(ptr1) = ____;
3. sizeof 和 strlen 区别

在这里插入图片描述

2. C语言中动态内存管理方式：malloc/calloc/realloc/free

 void Test ()
{
int* p1 = (int*) malloc(sizeof(int));
free(p1);
// 1.malloc/calloc/realloc的区别是什么？
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
// 这里需要free(p2)吗？
free(p3 );
}

3. C++内存管理方式

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

这里的new和delete可以类比malloc和free；

3.1 new/delete操作内置类型的定义和初始化

new操作符：

int main()
{
	//动态申请一个int类型的空间；
	int* ptr4 = new int;
	//动态申请一个int类型的空间并初始化
	int* ptr5 = new int(10);
	//动态申请10个int类型的空间
	int* ptr6 = new int[10];
		//动态申请10个int类型的空间并初始化
	int* ptr7 = new int[10]{ 1,2,3 };//注意【】和{}之间没有=；
	return 0;
}
}

delete操作符销毁单个变量和数组

销毁变量
delete ptr4;
delete ptr5;
销毁数组
delete[]ptr6;

相比malloc更加简化了；

图解
在这里插入图片描述
c++兼容c语言；可以使用malloc和new；

3.2 new和delete操作自定义类型

new操作符

int main()
{
	//动态申请一个A类型的空间；
	A* ptr1 = new A;
	//动态申请一个A类型的空间并使用构造函数初始化
	A* ptr2 = new A(1);//()传参是初始化
	//动态申请10个A类型的空间
	A* ptr6 = new A[10];
	//动态申请10个int类型的空间并初始化
	A aa1(1);
	A aa2(2);
	A* p5 = new A[10]{ aa1,aa2 };//正常对象
	A* p6 = new A[10]{ A(1),A(2) };//匿名对象
	A* p7 = new A[10]{ 1,2 };//隐式类型转换
	return 0;
	
}

delete操作符

销毁变量
delete ptr4;
delete ptr5;
销毁数组
delete[]ptr6;

new和malloc的最大区别在自定义类型
malloc开辟自定义空间太困难；所以多使用new；
在这里插入图片描述
new相比malloc调用构造函数；
delete相比free调用析构函数；

3.3new和delete的调用顺序

在这里插入图片描述

4. operator new与operator delete函数（重要点进行讲解）

4.1 operator new与operator delete函数（重点）

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

4. 1.1 operator new（申请空间）

这里的operator new 本质是malloc；两者用法相同；
在这里插入图片描述
只是名字不同；

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);
}

4.1.2 operator delete （释放空间）

这里的operator delete 本质是 free

/*
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来申请空间，operator delete 最终是通过free来释放空间的。

5. new和delete的实现原理

5.1前序

抛异常：
结构如下：

try
{
//这里直接调用或间接调用new语句；
//这里如果失败，跳入catch语句；

}
catch（const exception& e)
{
    cout <<e.what()<<endl;
}

直接调用:
在这里插入图片描述
间接调用：

在这里插入图片描述

5.2 内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，
不同的地方是：
1.new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，
2. new在申请空间失败时会抛异常，malloc会返回NULL。
内置类型只需要开空间，不需要初始化；

5.3 自定义类型

new的原理

调用operator new函数申请空间
在申请的空间上执行构造函数，完成对象的构造
delete的原理
在空间上执行析构函数，完成对象中资源的清理工作
调用operator delete函数释放对象的空间
new T[N]的原理
调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
在申请的空间上执行N次构造函数
delete[]的原理
在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

不匹配问题：
内置类型：
内置类型调用这三个语句都能实现释放空间
在这里插入图片描述
自定义类型：

使用free来释放时：

free特点将开辟的空间释放；不调用析构函数
使用delete时间：

delete特点：调用一次析构函数；并释放空间；
使用delete【】时：

在这里插入图片描述
delete【】特点：调用N次析构函数；并释放空间；

这里：free delete和delete【】的区别：
在这里插入图片描述

6. 定位new表达式(placement-new) （了解）

在这里插入图片描述

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

class A
{
public:
 A(int a = 0)
 : _a(a)
 {
 cout << "A():" << this << endl;
 }
 ~A()
 {
 cout << "~A():" << this << endl;
 }
private:
 int _a;
};
// 定位new/replacement new
int main()
{
 // p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没
有执行
 A* p1 = (A*)malloc(sizeof(A));
 new(p1)A;  // 注意：如果A类的构造函数有参数时，此处需要传参
 p1->~A();
 free(p1);
 A* p2 = (A*)operator new(sizeof(A));
new（p2)A(10);//显示调用析构函数
 p2->~A();
 operator delete(p2);
  return 0;
}

在这里插入图片描述

对于析构函数；使用对象直接调用
在这里插入图片描述

7. 常见面试题

7.1 malloc/free和new/delete的区别

在这里插入图片描述

嘉城401

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C/C++内存管理

int main()//动态申请一个int类型的空间；//动态申请一个int类型的空间并初始化//动态申请10个int类型的空间//动态申请10个int类型的空间并初始化//注意【】和{}之间没有=；return 0;delete操作符销毁单个变量和数组销毁变量销毁数组相比malloc更加简化了；图解c++兼容c语言；可以使用malloc和new；new操作符int main()//动态申请一个A类型的空间；//动态申请一个A类型的空间并使用构造函数初始化。
复制链接

扫一扫