【C++】C&C++内存管理

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. 栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信
3. 堆用于程序运行时动态内存分配，堆是可以上增长的
4. 数据段–存储全局数据和静态数据
5. 代码段–可执行的代码/只读常量

这里解释一下，为什么说栈是向下增长的，堆是向上增长的

在申请空间的时候，栈先申请的空间是高地址，后申请的空间是低地址，堆先申请的空间是低地址，后申请的是高地址，所以说栈是向下生长，堆是向上生长

看下面一段代码:

void Test_stack()
{
    //在栈区开辟a，b两个变量，先开辟的变量地址高
	int a = 10;
	int b = 20;
	cout << "&a=" << &a << endl;
	cout << "&b=" << &b << endl;
    //在堆区开辟aa和bb，先开辟的地址低
	int* aa = (int*)malloc(sizeof(int) * 2);
	int* bb = (int*)malloc(sizeof(int) * 2);
	cout << "aa=" << aa << endl;
	cout << "bb=" << bb << endl;
}

注意：在堆区先开辟的不一定就比后开辟的地址低，也有可能开辟的是之前释放的内存。

2.C语言中动态内存的管理方式

在C语言中，通过四个函数来管理动态内存的，分别是malloc，realloc，calloc，free

1.malloc

malloc函数在内存中开辟一块指定大小的连续地址空间，并返回该空间的首地址，如果开辟不成功就返回NULL

2.calloc

calloc函数的功能也是在内存中开辟一块指定大小的连续地址空间，并返回该空间的首地址，在开辟的过程中，可以给定每个字节的初始值，如果开辟不成功则返回NULL

3.realloc

realloc函数的功能是修改动态开辟的内存大小，并返回修改后的内存地址空间首地址。

4.free

free函数的功能是释放动态开辟的内存

更详细的内容请看下面这篇博客：【C语言进阶】动态内存管理_小张在努力写代码的博客-CSDN博客

3. C++中动态内存的管理

在C++中，同样可以使用C语言中提供的内存管理方式，但是对于某些情况下，开辟自定义类型时，使用malloc等函数会出现一些问题，所以在C++中，用了新的内存管理方式-----new和delete

1.new/delete操作内置类型

void Test_new_delete_Built()
{
	//操作内置类型
	//动态申请一个整型大小的空间
	int* ptr1 = new int;
	//动态申请一个整型大小的空间，并初始化为10
	int* ptr2 = new int(10);
	//动态申请10个整型大小的空间
	int* ptr3 = new int[10];
	//对于new申请的空间，使用delete释放
	delete ptr1;
	delete ptr2;
	//对于new[]申请的空间，使用delete[]释放
	delete[] ptr3;
}

new和malloc的区别

对于malloc：开辟空间失败返回空指针

对于new：开辟空间失败直接抛异常，不需要检查返回值

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

new/delete和malloc/calloc/realloc/free的真正区别在于自定义类型

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

void Test_Custom()
{
	cout << "malloc:" << endl;
	A* pA1 = (A*)malloc(sizeof(A));
	cout << pA1 << endl;
	cout << "------------------------------" << endl;
	free(pA1);
	cout << "new:" << endl;
	A* pA2 = new A();
	delete pA2;
}

可以看到，new/delete和malloc等C语言接口的区别就是new和delete调用了自定义类型的默认构造函数和析构函数，而malloc等接口不会调用，只起了管理内存的作用。

总结：

1. 在对于内置类型的内存管理的时候，使用new/delete和malloc/calloc/realloc/free没有什么去区别

2. 在对于自定义类型的内存管理的时候，new做了开辟内存+调用默认构造函数，delete做了释放内存+调用析构函数

3. 使用new开辟的空间要使用delete释放，使用new[]开辟的空间要使用delete[]释放

4. 建议在C++中无论是内置类型还是自定义类型的申请和释放，尽量都使用new和delete

4.operator new和operator delete函数

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

new的底层机制

1. operator new --> malloc
2. 调用构造函数

class A
{
public:
	A(int* a = nullptr)
		:_a(a)
	{
		cout << "A()" << this << endl;
	}
	~A()
	{
		cout << "~A()" << this << endl;
	}
private:
	int* _a;
};
void Test()
{
	A* p = new A;
}

通过查看汇编代码，可以看到new的这个操作做了：1. 调用operator new 2. 调用自定义类型的构造函数

---

注意：operator new看起来像是运算符重载，但是，实际上operator new不是运算符重载，因为在该函数参数中没有自定义类型

//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失败之后的返回NULL封装成抛出异常，执行用户提供的应对措施。operator delete最终也是通过free来释放空间的。

5.new和delete的实现原理

1.内置类型

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

2.自定义类型

1. new的原理

1. 调用operator new函数在内存中申请空间
1. 在申请的空间上执行该类型的构造

2. delete的原理

1. 在空间上执行该类型的析构函数
1. 调用operator delete函数释放空间

3. new T[N]的原理

1. 调用operator new[]函数，operator new[]函数实际上就是封装了operator new函数，执行N次operator new
1. 在申请的空间上执行N次该类型的构造函数

4. delete[]的原理

1. 在申请的空间上执行N次析构函数
1. 调用operator delete[]函数，operator delete[]实际上就是封装了operator delete函数，执行N次operator delete[]

6.定位new表达式(placement-new)

定位new表达式的作用是在已经分配过的原始内存空间中调用构造函数初始化一个对象

使用格式

new(place_address)type或者new(palce_address)type(initializer-list)

其中，place_address必须是一个指针，initializer-list是类型的初始化列表

使用场景

class A
{
public:
	A(int a = 5)
		:_a(a)
	{
		cout << "A()" << this << endl;
	}
	~A()
	{
		cout << "~A()" << this << endl;
	}
private:
	int _a;
};
void Test_replacement_new()
{
	//new (place_address) type
	A* p1 = (A*)malloc(sizeof(A));
	if (p1 == nullptr)
	{
		perror("malloc fail");
		exit(-1);
	}
	new(p1)A();
	p1->~A();
	free(p1);
	//new (place_address) type(initializer-list)
	A* p2 = (A*)operator new(sizeof(A));
	new(p1)A(10);
	p2->~A();
	free(p2);
}

注：不管是在执行了malloc还是执行operator new之后，p1p2都只是一段大小于A对象大小相同的空间，不是一个对象，因为构造函数还没有执行

7.常见的面试题

1.malloc/free和new/delete的比较

从用法功能和底层两个方面去考虑

• 共同点：

  都是从堆上申请空间，并且需要手动释放

• 不同点

  1. malloc/free是函数，new/delete是操作符
  2. malloc申请的空间不会初始化，new申请的空间会调用构造函数初始化
  3. malloc申请空间需要手动传要开辟的空间的字节数大小，new申请空间只需要传类型个数
  4. malloc返回值类型是void*，需要进行强转之后使用，new不需要
  5. malloc申请失败返回NULL，用的时候需要进行判空操作，new申请失败抛异常，需要捕获异常
  6. malloc和free只会开辟空间，不会对空间进行操作，new和delete在完成malloc和free功能的基础上，会自动调用构造函数和析构函数。
  7. new的底层也是封装了malloc实现的，delete底层也是封装了free实现的

2.内存泄漏

1. 什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏是指因为某些原因导致的程序没有释放不再使用的内存。内存泄漏不是物理上的消失，而是值操作系统将内存分配给程序之后，失去了对该部分内存的控制，导致操作系统找不到该内存，从而造成的内存浪费

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

2. 内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏：

• 堆内存泄漏(Heap leak)
  堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
• 系统资源泄漏
  指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定

3. 如何检测内存泄漏

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

因此写代码时一定要小心，尤其是动态内存操作时，一定要记着释放。但有些情况下总是防不胜防，简单的可以采用上述方式快速定位下。如果工程比较大，内存泄漏位置比较多，不太好查时一般都是借助第三方内存泄漏检测工具处理的 。

• 在linux下内存泄漏检测 ：Linux下几款C++程序中的内存泄露检查工具

• 在windows下使用第三方工具： VLD工具说明

• 其他工具 ：内存泄露检测工具比较

4. 如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能。
4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

内存泄漏非常常见，解决方案分为两种：

1. 事前预防型。如智能指针等
2. 事后查错型。如泄漏检测工具