【C++初阶】第五站:C/C++内存管理 (匹配使用，干货到位)

前言：

本文知识点：

1. C/C++内存分布2. C语言中动态内存管理方式3. C++中动态内存管理4. operator new与operator delete函数 5. new和delete的实现原理 （干货在此）

6. 定位new表达式(placement-new)7. 常见面试题

C/C++内存分布

1.内存划分题

2.sizeof 和 strlen 区别？

3.计算sizeof和strlen题

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

malloc/calloc/realloc和free

C++内存管理方式

new/delete操作内置类型

new和delete操作自定义类型

对于单链表的改进

new和delete的应用

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

operator new与operator delete函数（重点）

new和delete的实现原理

干货在这（了解即可）：

定位new表达式(placement-new)

常见面试题

malloc/free和new/delete的区别

内存泄漏

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.内存划分题

题解:

内存区域划分：

【说明】

1.栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。

2.内存映射段是高效的 I/O 映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。(未学到linux仅作了解即可)

3.堆用于程序运行时动态内存分配，堆是可以上增长的。

4.数据段--存储全局数据和静态数据。

5.代码段--可执行的代码/只读常量。

2.sizeof 和 strlen 区别？

这篇文章有详细的总结 --> 指针进阶(3) -- 关于sizeof和strlen的详细总结

在C/C++中：

sizeof：这是一个运算符，编译时确定，用于计算变量或类型的大小（以字节为单位），包括数组、指针、结构体等。对于字符数组或字符串，它返回整个数组（包括结束符 \0）的总字节数。

strlen：这是一个库函数，运行时确定，用于计算以 \0 结尾的字符串的实际字符数，不包括结束符 \0。因此，对于包含字符串的字符数组，strlen 返回的是字符串的有效字符数量。

简单地说：

sizeof 计算内存容量；
strlen 计算字符串长度。

3.计算sizeof和strlen题

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

malloc/calloc/realloc和free

#include<stdio.h>
#include<malloc.h>
int main()
{
	int* p1 = (int*)malloc(sizeof(int));
	free(p1);
	int* p2 = (int*)calloc(4, sizeof(int));
	// 这里需要free(p2)吗？
	//free(p2);
	int* p3 = (int*)realloc(p2, sizeof(int) * 10);
	free(p3);
}

为什么不需要free(p2)?

因为p2申请了四个字节的空间，此基础上，如果free掉p2,那么p3申请空间的时候，p2指向那块空间已经属于操作系统了，这时候再操作就引发野指针异常

⭕ 【面试题】

1. malloc/calloc/realloc的区别？

malloc:

功能：动态分配指定字节数的内存。
特点：不会初始化分配的内存，内容随机。
语法：void* malloc(size_t size);
示例：int *p = (int*)malloc(sizeof(int)*n); 分配n个整数大小的连续内存空间。

calloc:

功能：动态分配指定数量、特定类型的内存空间，并初始化为0。
特点：不仅分配内存，还会清零初始化。
语法：void* calloc(size_t num, size_t size);
示例：int *p = (int*)calloc(n, sizeof(int)); 分配并初始化n个整数大小的连续内存空间为0。

realloc:

功能：调整已分配内存块的大小，可以扩大或缩小。
特点：如果扩大内存，新增空间内容不确定；如果缩小内存，多余部分会被释放，缩小后的内存区域保持不变。
语法：void* realloc(void* ptr, size_t new_size);
示例：int *new_p = (int*)realloc(p, sizeof(int)*m); 尝试更改指针p指向的内存区域大小为m个整数所需空间，返回新的内存地址，有可能与原地址相同也可能不同。

总的来说：

malloc 用于单纯分配未初始化的内存。
calloc 用于分配并初始化为零的内存。
realloc 用于调整已分配内存区域的大小，提供了一种灵活的内存管理手段。

更多详细内容请移步到 --> 【C进阶】-- 动态内存管理

C++内存管理方式

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因

此C++又提出了自己的内存管理方式：通过 new和delete 操作符进行动态内存管理。

new/delete操作内置类型

内置类型是几乎是一样的:

malloc和new对于内置类型都 只会申请空间但不会初始化 ,因为 new没有调构造函数

同样对于delete和free来说，都只会释放对象的空间， delete不会调用析构函数

int main()
{
     int* p3 = (int*)malloc(sizeof(int)); // C
     int* p4 = new int;//这个地方还是随机值(内置类型不会调构造)
     free(p3);
     delete p4;
}

对于内置类型的详细例子

include<stdio.h>
#include<malloc.h>
#include<iostream>
using namespace std;
int main()
{
	//不会初始化的例子

	    int* p2 = (int*)malloc(sizeof(int));
	//自动计算大小,不需要强转，动态申请一个int类型的空间
	    int* p3 = new int;
	//动态分配一块足够存储 10 个整数的连续内存空间
	    int* p4 = (int*)malloc(sizeof(int) * 10);
	// 动态申请10个int类型的空间
	    int* p5 = new int[10];
	
	//malloc的释放方式
	    //free(p2);
	    //free(p4);
	//new的释放方式
	    //delete p3;
	    //delete[] p5;

	//会初始化的例子
	
	//额外支持空间 + 初始化
	//动态申请一个int类型的空间
	    int* p6 = new int(10);
	// 动态申请10个int类型的空间,并初始化前三个
	    int* p7 = new int[10]{ 1,2,3 };
	// 动态申请10个int类型的空间
	    int* p8 = new int[10]{};

	return 0;
}

注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用 new[]和delete[],注意：匹配起来使用！！！

还需注意的是：

new和delete操作自定义类型

new/delete 和 malloc/free 最大区别是：

new/delete 对于【自定义类型】除了开空间 /释放空间，还会调用 构造函数和析构函数

示例：

int main()
{
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;
}

自定义类型A,代码示例:

class A
{
public:
	A(int a=0)
	:_a(a)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
int main()
{
	//malloc没有办法很好地支持动态申请的对象初始化
	A* p1 = (A*)malloc(sizeof(A));
}

malloc没有办法很好地支持动态申请的对象初始化

new的使用:开空间，加构造函数初始化

int main()
{
    A* p2 = new A; //0也是初始化，如果没有初始化就是随机值了
    A* p3 = new A(3);
}

执行：

delete的使用:自定义类型，调用析构函数+释放空间

int main()
{
//开空间，加构造函数初始化    
    A* p2 = new A;
	A* p3 = new A(3);
//调用析构函数+释放空间
	delete p2;
	delete p3;
}

调用默认构造初始化

int main()
{
    A* p4 = new A[10];
	delete[] p4;
}

调用显示构造初始化

int main()
{
    A aa1(2);
	A aa2(3);
	A* p5 = new A[10]{ aa1,aa2 };//使用有名对象进行数组初始化
	delete[] p5;
}

使用了匿名对象进行数组初始化

int main()
{
    A* p6 = new A[10]{ A(1),A(2)};//使用了匿名对象进行数组初始化
	delete[] p6;
}

使用int型数据进行数组初始化

总结：

在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，

而malloc与 free不会

对于单链表的改进

原单链表：【数据结构】C--单链表

改进后：

#include <iostream>
using namespace std;
struct ListNode
{
	int _val;
	ListNode* next;

	ListNode(int _val = 0)
	:_val(_val), next(nullptr) 
	{}
};

// 打印链表函数
void PrintList(ListNode* head) {
	while (head != nullptr) {
		cout<<head->_val;
		if (head->next != nullptr) {
			cout << "->";
		}
		head = head->next;
	}
	cout << endl;
}

int main() {
	ListNode* n1 = new ListNode(1);
	ListNode* n2 = new ListNode(2);
	ListNode* n3 = new ListNode(3);
	ListNode* n4 = new ListNode(4);
	ListNode* n5 = new ListNode(5);

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = n5;
	n5->next = nullptr;

	PrintList(n1);  // 调用函数打印链表

	// 记得在最后释放内存...
	delete[] n1;

	return 0;
}

new和delete的应用

尝试：返回一个指向栈对象的指针

以下的写法均不可取：

改正：

代码：

#include<iostream>
using namespace std;
typedef char DataType;
class Stack
{
public:
	Stack(size_t capacity = 4)
	{
		cout << "Stack()" << endl;
		_array = new DataType[capacity];
		_capacity = 0;
		_size = 0;
	}
	void Push(DataType data)
	{
		_array[_size] = data;
		_size++;
	}
	
	~Stack()
	{
		cout << "~Stack()" << endl;
		delete[] _array;
		_array = nullptr;
		_size = _capacity = 0;
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};
Stack* func()
{
	int n;
	cin >> n;
	Stack* pst = new Stack(n);
	return pst;
}
int main()
{
	Stack* ptr = func();
	ptr->Push(1);
	ptr->Push(2);

	delete ptr;
	return 0;
}

执行：

还有一个注意的点：

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

operator new与operator delete函数（重点）

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是

系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过 operator delete全局函数来释放空间。

对于内置类型，在内存分配的基本功能上， operator new和malloc，以及operator delete 和 free 的 用法几乎是一样的，即都可用于在堆上分配和释放内存
#include<iostream>
using namespace std;
int main()
{
	//以下三种方式开辟空间和释放空间的效果是一样的
	int* p1 = (int*)malloc(sizeof(int));      //malloc
	free(p1);//free

	int* p2 = new int;     //new
	delete p2;//delete

	int* p3 = (int*)operator new(sizeof(int));//operator new
	operator delete (p3);//operator delete
	return 0;
}

总结：

operator new:该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回;申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。

operator delete: 该函数最终是通过free来释放空间的

为什么要封装operator new:

C++中当开辟空间失败会抛异常，可以通过代码实现捕获异常，这是C++的一个编程规范， 如果直接用malloc，申请失败会返回NULL。但是如果没有对这个进行处理的话，会将 这个NULL当作返回成功，正常使用了，原本应该是要抛异常的.

C++遇到一个 new 和 delete 做了什么事情:

底层汇编代码：

operator new与operator delete底层源码

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和delete的实现原理

内置类型

如果申请的是内置类型的空间，new和malloc，delete和free 基本类似，不同的地方是:

new/delete 申请和释放的是单个元素的空间， new[]和delete[ ]申请的是连续空间，

而且 new在申请空间失败时会抛异常，malloc会返回NULL。

自定义类型

new的原理

1. 调用operator new函数申请空间

2. 在申请的空间上执行构造函数，完成对象的构造

delete的原理

1. 在空间上执行析构函数，完成对象中资源的清理工作

2. 调用operator delete函数释放对象的空间

new T[N]的原理

1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对

象空间的申请

2. 在申请的空间上执行N次构造函数

delete[]的原理

1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理

2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

这里会不会内存泄露? 不会(内置类型)

#include<iostream>
using namespace std;
int main()
{
	int* p1 = new int[10];
	//free(p1);
	delete p1;
	//delete[]p1;
}

对于自定义类型:

而写没写析构也会出现报错， 原因是指针释放的位置不对

永远记住一个点： 匹配使用！匹配使用！匹配使用！ ( 没有写析构函数是不会报错的，但用free的话可能会导致内存泄露，因为没调析构)

干货在这（了解即可）：

由于编译器的原因,以下的两张图，左边写了析构的，会在申请的空间前面多申请4byte ，然后这4个字节用来存 10(因为new的时候是10个int数据）,注意：这里的存的 10是个数，不是字节

        如果用delete[ ]，它就会自动偏移到新开的4byte的空间和后面原本的空间是合并在一起的，所以释放的时候一把释放是没问题，并且是释放了10次(释放不能分期，不能分段)

        但是如果你用delete 和free 的话，那编译器就不会偏移了，因为new 或者 malloc 的时候就是那么多，所以你释放的时候就那么多。因此，如果写了析构,这个时候用 delete 或者 free 只会把4byte后面的空间给释放掉，编译器会报错

        所以 右边的那副图，没写析构，但没报错的原因是因为 指针的位置没有指向错误。

指针 - 1位置正确，但是析构函数没调够

定位new表达式(placement-new)

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

使用格式：

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

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

使用场景：

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

内存池的浅显理解：

在C++中， 构造函数 是不能通过指针或者对象实例名直接调用的，只能在创建对象时自动调用。如果这些内存不是从堆里面获取的， 是从内存池里面获取的，那就需要显示调用构造和析构，

include<iostream>
using namespace std;
内存池
int main()
{
	// p1现在指向的只不过是与Stack对象相同大小的一段空间，
	//还不能算是一个对象，因为构造函数没有执行
	Stack* pst1 = (Stack*)operator new(sizeof(Stack));
	//pst1->Stack(4);//不支持
	new(pst1)Stack(4);//显示调用构造函数
                      //注意：如果A类的构造函数有参数时，此处需要传参

	pst1->~Stack();//可以显示调用析构
	operator delete(pst1);//显示调用析构函数
	return 0;
}

常见面试题

malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。

🌊 不同的地方是 ：

malloc和free是函数，new和delete是操作符
malloc申请的空间不会初始化，new可以初始化
malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[ ]中指定对象个数即可。
malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型。
malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常。
申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new 在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理。

内存泄漏

内存泄漏概念与危害

什么是内存泄漏

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。

内存泄漏并不是指内存在物理上的消失，

而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄露的危害

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

代码如下：

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

内存泄漏分类（了解）

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

堆内存泄漏(Heap leak)

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new 等从堆中分配的一

块内存，用完后必须通过调用相应的 free 或者 delete 删掉。

假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak 。

系统资源泄漏

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

如何检测内存泄漏（了解）

在linux下内存泄漏检测：linux下几款内存泄漏检测工具
在windows下使用第三方工具：VLD工具说明
其他工具：内存泄露检测工具比较

如何避免内存泄漏

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

总结一下: