C++---内存管理

一、C/C++内存分布

C/C++程序内存区域划分：

对于上图区域的理解？

①栈---又称堆栈，存放非静态局部变量/函数参数/返回值等，栈是向下增长的。

②内存映射段---高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信。

③堆---用于程序运行时动态内存分配，堆是向上增长的。

④数据段---存储全局数据和静态数据，语言上称之为静态区。

⑤代码段---可执行的代码/可读常量，语言上称之为常量区。

为什么要划分内存区域？

划分内存区域--->便于管理

重点注意的区域？

堆区，因为堆区开辟空间、销毁空间是由程序员自己操作、控制的。

如果我们开辟了堆区空间而使用完不进行销毁，就会有内存泄漏的风险。

举一个例题来加强对于不同区域存储数据的理解：

二、C语言内存管理方式

在C语言中，对于内存管理，我们使用malloc、calloc、realloc、free函数来进行空间的开辟、扩容、销毁。

对于这些函数，我们需要掌握它们的使用方式，同时需要知道malloc、calloc、realloc三者的区别。

malloc：括号中一个参数---空间大小，成功开辟空间后不会对空间进行初始化。

calloc：括号中两个参数---数据个数、每个数据大小，成功开辟空间后会对空间进行初始化。

realloc：括号中两个参数---指针(指向原空间首元素)、扩容后总空间大小，有两种开辟形式：若原空间其后空间足够，则在其后接着开辟；若不够，则重新寻找一块足够的空间，并将原空间数据拷贝到新空间中，然后销毁原空间。

三、C++内存管理方式

C语言的内存管理方式可以在C++中使用，但是C++拥有属于自己的操作符new和delete来进行动态内存管理。

C语言相关动态内存管理的malloc、calloc、realloc、free属于函数，而C++中是使用操作符来进行动态内存管理的。

1.new、delete操作内置类型

new + 类型，能够在堆区开辟一个该类型对象的空间；

new + 类型[n]，在堆区开辟n个该类型对象的空间；

new + 类型[n]{1,2,3,...}，在堆区开辟n个该类型对象的空间并对空间进行初始化，未写出部分初始化0。如new int[5]{1,2,3}，初始化{1,2,3,0,0}。

delete + 指针，销毁一个对象空间；

delete[] + 指针，销毁多个对象空间。

简单地说，new开辟时若开辟了多个对象的空间，即使用了 [ ] ，则对应销毁时使用delete[]而非delete；new开辟一个对象的空间，则使用delete。new与delete的使用需要对应。

2.new、delete操作自定义类型

new和delete操作自定义类型时，除了开辟空间，还会自动调用其对应的构造函数和析构函数。

而在C语言中的malloc等就只能开辟空间，不会去调用构造/析构函数，需要自己进行赋值。

class A
{
public:
	A(int a)
	:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

3.new/delete相较malloc等的优点

也可以说是C++在动态内存管理上较C语言的优点。

①new/delete用法上更简洁，代码量更少。

②new开辟空间不需要判断是否成功，new失败会抛出异常，不需要手动检查。

③new开辟空间可以同时进行初始化，一个对象初始化使用()，多个对象使用[]{}。

④new/delete操作自定义类型时，在开辟空间的同时还会调用其构造/析构函数。调用构造函数时进行初始化，调用析构函数时进行销毁操作。malloc/free操作自定义类型不会调用构造/析构函数

四、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实现
         _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和operator delete的实现，其实operator new也是通过malloc来开辟空间的，只不过不只有malloc，申请成功直接返回，否则执行用户提供的空间不足措施，如果用户提供该措施则继续申请，否则抛异常。operator delete也是通过free来释放空间的。 

new的底层是operator new + 调用构造函数，而delete的底层是调用析构函数 + operator delete，为什么delete底层先调用析构函数？

举例说明：

五、new与delete实现原理

操作内置类型

new与delete用于申请与释放单个元素的空间；new 类型[N]与delete[] 用于申请、释放一块连续空间，new在申请失败时会自动抛异常，不需要手动检查，malloc申请失败返回nullptr，需要手动判断。

操作自定义类型

1.new

①operator new开辟空间；

②调用构造函数初始化。

2.delete

①调用析构函数完成对象中资源的清理工作；

②operator delete释放对象的空间。

3.new 类型[N]

①调用operator new[]函数，等于调用operator new函数完成对N个对象空间的开辟；

②调用N次构造函数对N个对象进行初始化。

4.delete[]

①调用N次析构函数清理即将释放的N个对象中的资源；

②调用operator delete[]释放空间，实际调用operator delete完成对N个对象的空间释放。

编译器对于new[N]/delete[]的微处理

我们在没有显式实现析构函数时，通过反汇编我们发现，需求申请10个C类对象的空间，编译器开辟了40字节，因为成员只有一个int类型，这没有任何问题。

但是当我们显式实现了析构函数，反汇编发现，编译器开辟了44字节空间。

那么为什么会多开辟4字节呢？

这其实是源于delete[ ]的析构过程。

我们在使用delete[ ]析构时，编译器是怎么知道具体要析构多少次的呢？

多开辟的4字节，其实存放的是delete[ ]的析构次数。实际上，如果编译器使用默认生成的析构函数，就会"偷懒"，因为编译器知道，默认生成的析构函数没有多次执行的意义，就不会去多次执行析构，但是如果用户显式实现了析构函数，编译器无法违背用户指令，必须执行该析构函数。因此为了得到析构次数，就会在开辟的目标空间前开辟4字节空间用于存储析构次数。

如果额外开辟空间了，而我们错误地使用delete，而没有使用delete[]，会导致报错！原因在于delete调用析构，然后调用operator delete释放这块空间，但是c2指向并不是空间初始位置，operator delete底层仍然是free，free不能够从一块空间中间释放，因此报错。

new与delete的使用得匹配，有[ ]就都得有[ ]，没有就都没有。

上述区别针对自定义类型，且用户显式实现了析构函数。

对于内置类型而言，不存在调用析构与构造之说，自然也就不会去多开辟额外的空间。

六、定位new表达式(placement-new)

概念：定位new表达式，是在已分配的空间中，调用构造函数初始化该对象。

使用方式：new ( 指针 ) 类型 ( 初始化列表 )

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

举例：

我们一般不能显式调用析构函数，若不使用new与delete，可以先operator new开辟空间，然后定位new调用构造函数初始化，然后通过显式调用析构清理对象内资源，最后operator delete释放对象空间。构造函数不能显式调用，要调也要通过定位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;
}

七、掌握并区分关键概念

1.malloc/free和new/delete的区别

共同点：都是在堆上开辟空间，都需要用户手动释放。

不同点：

①new/delete用法更简洁；malloc/free繁冗：new申请单个对象空间+类型，多个对象空间+类型[N]即可；malloc需要手动计算大小并传递。

②new/delete是操作符；malloc/free是函数。

③new可以初始化；malloc不能初始化。

④new后跟空间的类型；malloc返回值为void*类型，使用时必须强转。

⑤new申请失败抛异常；malloc申请失败返回nullptr，需要手动判空。

⑥申请自定义类型对象空间时，new申请空间并自动调用构造函数、delete自动调用析构函数清理对象内资源并释放对象空间；而malloc/free只能开辟/释放空间，不会去调用构造/析构函数。

2.内存泄漏

概念：已经使用完的空间没有得到释放，产生内存泄漏。说的详细一点，内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

危害：长期运行的程序出现内存泄漏，影响很大：如操作系统、后台服务、游戏服务器等，出现内存泄漏会导致响应越来越慢，最终卡死。

void MemoryLeaks()
{
   // 1.内存申请了忘记释放
  int* p1 = (int*)malloc(sizeof(int));
  int* p2 = new int;
  
  // 2.异常安全问题
  int* p3 = new int[10];
  
  Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
  
  delete[] p3;
}

分类：

①堆内存泄漏(HeapLeak)

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

②系统资源泄露

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

检测内存泄漏方法

在vs下，可以使用windows操作系统提供的_CrtDumpMemoryLeaks() 函数进行简单检测，该函数只报出了大概泄漏了多少个字节，没有其他更准确的位置信息。

可以借助第三方工具检测内存泄漏：Windows下使用VLD工具。

如何避免内存泄漏

①工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。

②采用RAII思想或者智能指针来管理资源。

③有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。

④出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

内存泄漏解决方案分为两种：①事前预防：如智能指针；②事后查错：如泄露检测工具。