• 【C++】内存管理（学习复习兼顾）

    目录

    0.前言

    1. C/C++内存分布

    说明：

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

    2.1 malloc/calloc/realloc和free

    面试题：

    3. C++内存管理方式 

    3.1 new/delete操作内置类型

    注意：

    3.2 new和delete操作自定义类型

    注意：

    总结：

    4. operator new与operator delete函数（重点）

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

    总结： 

     4.2 operator new与operator delete的类专属重载（了解）

    5. new和delete的实现原理

    5.1 内置类型

    5.2 自定义类型

    原理：

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

    使用格式：

    使用场景：

     7. 常见面试题

    7.1 malloc/free和new/delete的区别（使用上）

    7.2 内存泄漏

    7.2.1 什么是内存泄漏，内存泄漏的危害

    7.2.2 内存泄漏分类（了解）

    7.2.3 如何避免内存泄漏

    总结：

    7.3 如何一次在堆上申请4G的内存？

    0.前言

            此博客为博主以后复习的资料，所以大家放心学习，总结的很全面，每段代码都给大家发了出来，大家如果有疑问可以尝试去调试。

            大家一定要认真看图，图里的文字都是精华，好多的细节都在图中展示、写出来了，所以大家一定要仔细哦~

    1. C/C++内存分布

            我们先来看下面的一段代码和相关问题，大家认真看哦，虽然简单，但是要想全对也不是很容易哦~

    1. int globalVar = 1;
    2. static int staticGlobalVar = 1;
    3. int main()
    4. {
    5. 	static int staticVar = 1;
    6. 	int localVar = 1;
    7.  
    8. 	int num1[10] = { 1, 2, 3, 4 };
    9. 	char char2[] = "abcd";
    10. 	const char* pChar3 = "abcd";
    11. 	int* ptr1 = (int*)malloc(sizeof(int) * 4);
    12. 	int* ptr2 = (int*)calloc(4, sizeof(int));
    13. 	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
    14. 	free(ptr1);
    15. 	free(ptr3);
    16.  
    17. 	return 0;
    18. }
    19.  
    20. 1. 选择题：
    21. //选项 : A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
    22. //globalVar在哪里？____ staticGlobalVar在哪里？____
    23. //staticVar在哪里？____ localVar在哪里？____
    24. //num1 在哪里？____
    25. //
    26. //char2在哪里？____ * char2在哪里？___
    27. //pChar3在哪里？____ * pChar3在哪里？____
    28. //ptr1在哪里？____ * ptr1在哪里？____
    29. 2. 填空题：
    30. //sizeof(num1) = ____;
    31. //sizeof(char2) = ____; strlen(char2) = ____;
    32. //sizeof(pChar3) = ____; strlen(pChar3) = ____;
    33. //sizeof(ptr1) = ____;
    34. //sizeof(char2) = ____; strlen(char2) = ____;
    35. //sizeof(pChar3) = ____; strlen(pChar3) = ____;
    36. //sizeof(ptr1) = ____;

             我上面将内存分段已经画了个大概，也将其进行了解释，接下来给大家一个完整的图，但是其他的分段对于初学者不是很需要清楚，只要清楚我上面画的分段就可以了~

    说明：

    1. 栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的。
    2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（这里大家可能不清楚，等我以后更新Linux的时候大家都会知道，所以大家现在先了解一下）
    3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
    4. 数据段--存储全局数据和静态数据。
    5. 代码段--可执行的代码/只读常量。

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

    2.1 malloc/calloc/realloc和free

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

            （因为这里是C语言的知识，我在这就不细讲了）

    面试题：

    malloc/calloc/realloc的区别？

    3. C++内存管理方式 

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

    3.1 new/delete操作内置类型

    1. void Test()
    2. {
    3.  // 动态申请一个int类型的空间
    4.  int* ptr4 = new int;
    5.  
    6.  // 动态申请一个int类型的空间并初始化为10
    7.  int* ptr5 = new int(10);
    8.  
    9.  // 动态申请10个int类型的空间
    10.  int* ptr6 = new int[3];
    11.  
    12.  delete ptr4;
    13.  delete ptr5;
    14.  delete[] ptr6;
    15. }

    注意：

            申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]，new/delete 和 new[]/delete[] 一定要匹配，否则会出错！

    3.2 new和delete操作自定义类型

            new/delete 和 malloc/free 针对内置类型没有任何差别，只是用法不一样。

            但是针对自定义类型有差别，malloc/free 只是开辟空间、释放空间，new/delete 开空间+构造函数初始化、析构函数清理 + 释放空间。

    1. class Test
    2. {
    3. public:
    4. 	Test()
    5. 		: _data(0)
    6. 	{
    7. 		cout << "Test():" << this << endl;
    8. 	}
    9. 	~Test()
    10. 	{
    11. 		cout << "~Test():" << this << endl;
    12. 	}
    13.  
    14. private:
    15. 	int _data;
    16. };
    17. void Test1()
    18. {
    19. 	// 申请单个Test类型的空间
    20. 	Test* p1 = (Test*)malloc(sizeof(Test));
    21. 	free(p1);
    22.  
    23. 	// 申请10个Test类型的空间
    24. 	Test* p2 = (Test*)malloc(sizeof(Test) * 10);
    25. 	free(p2);
    26. }
    27. void Test2()
    28. {
    29. 	// 申请单个Test类型的对象
    30. 	Test* p1 = new Test;
    31. 	delete p1;
    32.  
    33. 	// 申请10个Test类型的对象
    34. 	Test* p2 = new Test[10];
    35. 	delete[] p2;
    36. }

    注意：

            在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。

    总结：

    1. C++中如果是申请内置类型对象或者数组，malloc和new没什么区别
    2. 如果是自定义类型区别很大，new和delete是开空间+初始化、析构清理+释放空间，malloc和free仅仅是开空间+释放空间
    3. 建议在C++中，无论是内置类型还是自定义类型的申请释放，尽量使用new和delete

    4. operator new与operator delete函数（重点）

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

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

    1. /*
    2. operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，
    3. 尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。
    4. */
    5. void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
    6. {
    7. 	// try to allocate size bytes
    8. 	void* p;
    9. 	while ((p = malloc(size)) == 0)
    10. 		if (_callnewh(size) == 0)
    11. 		{
    12. 			// report no memory
    13. 			// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
    14. 			static const std::bad_alloc nomem;
    15. 			_RAISE(nomem);
    16. 		}
    17. 	return (p);
    18. }
    19. /*
    20. operator delete: 该函数最终是通过free来释放空间的
    21. */
    22. void operator delete(void* pUserData)
    23. {
    24. 	_CrtMemBlockHeader* pHead;
    25. 	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
    26. 	if (pUserData == NULL)
    27. 		return;
    28. 	_mlock(_HEAP_LOCK); /* block other threads */
    29. 	__TRY
    30. 		/* get a pointer to memory block header */
    31. 		pHead = pHdr(pUserData);
    32. 	/* verify block type */
    33. 	_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
    34. 	_free_dbg(pUserData, pHead->nBlockUse);
    35. 	__FINALLY
    36. 		_munlock(_HEAP_LOCK); /* release other threads */
    37. 	__END_TRY_FINALLY
    38. 		return;
    39. }
    40. /*
    41. free的实现
    42. */
    43. #define free(p) _free_dbg(p, _NORMAL_BLOCK)

            下面的代码和图片是一体的：

    1. struct ListNode
    2. {
    3. 	ListNode* _next;
    4. 	ListNode* _prev;
    5. 	int _val;
    6.  
    7. 	ListNode(int val)
    8. 		:_next(nullptr)
    9. 		, _prev(nullptr)
    10. 		, _val(val)
    11. 	{}
    12. };
    13.  
    14. void f()
    15. {
    16. 	// 他的用法跟malloc和free是完全一样的，功能都是在堆上申请释放空间
    17. 	// 失败了处理方式不一样，malloc失败返回NULL，operator new失败以后抛异常
    18. 	ListNode* p1 = (ListNode*)malloc(sizeof(ListNode));
    19. 	free(p1);
    20.  
    21. 	ListNode* p2 = (ListNode*)operator new(sizeof(ListNode));
    22. 	operator delete(p2);
    23.  
    24.  
    25. 	void* p3 = malloc(0x7fffffff);
    26. 	if (p3 == NULL)
    27. 	{
    28. 		cout << "malloc fail" << endl;
    29. 	}
    30.  
    31. 	void* p4 = operator new(11);
    32. 	//char* p5 = new char[0x7fffffff];
    33.  
    34. 	ListNode* p6 = new ListNode(0xffffffff);
    35.  
    36. 	cout << "继续" << endl;
    37. }
    38.  
    39. int main()
    40. {
    41. 	try
    42. 	{
    43. 		f();
    44. 	}
    45. 	catch (exception& e)
    46. 	{
    47. 		cout << e.what() << endl;
    48. 	}
    49.  
    50. 	return 0;
    51. }

            通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

    总结： 

     4.2 operator new与operator delete的类专属重载（了解）

            下面代码演示了，针对链表的节点ListNode通过重载类专属 operator new/ operator delete，实现链表节点使用内存池申请和释放内存，提高效率。

            （大伙看看就好，这里只是告诉大家有这个东西，后续我都会做成博客供大伙学习）

    1. struct ListNode
    2. {
    3. 	ListNode* _next;
    4. 	ListNode* _prev;
    5. 	int _data;
    6. 	void* operator new(size_t n)
    7. 	{
    8. 		void* p = nullptr;
    9. 		p = allocator<ListNode>().allocate(1);
    10. 		cout << "memory pool allocate" << endl;
    11. 		return p;
    12. 	}
    13. 	void operator delete(void* p)
    14. 	{
    15. 		allocator<ListNode>().deallocate((ListNode*)p, 1);
    16. 		cout << "memory pool deallocate" << endl;
    17. 	}
    18. };
    19. class List
    20. {
    21. public:
    22. 	List()
    23. 	{
    24. 		_head = new ListNode;
    25. 		_head->_next = _head;
    26. 		_head->_prev = _head;
    27. 	}
    28. 	~List()
    29. 	{
    30. 		ListNode* cur = _head->_next;
    31. 		while (cur != _head)
    32. 		{
    33. 			ListNode* next = cur->_next;
    34. 			delete cur;
    35. 			cur = next;
    36. 		}
    37. 		delete _head;
    38. 		_head = nullptr;
    39. 	}
    40. private:
    41. 	ListNode* _head;
    42. };
    43. int main()
    44. {
    45. 	List l;
    46. 	return 0;
    47. }

    5. new和delete的实现原理

    5.1 内置类型

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

    5.2 自定义类型

    原理：

    • 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来释放空间

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

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

    使用格式：

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

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

    使用场景：

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

    1. class A
    2. {
    3. public:
    4. 	A(int a = 0)
    5. 		: _a(a)
    6. 	{
    7. 		cout << "A():" << this << endl;
    8. 	}
    9.  
    10. 	~A()
    11. 	{
    12. 		cout << "~A():" << this << endl;
    13. 	}
    14.  
    15. private:
    16. 	int _a;
    17. };
    18.  
    19. int main()
    20. {
    21. 	// A* p = (A*)malloc(sizeof(A));
    22.  
    23. 	// 等价于直接用A* p = new A
    24. 	A* p = (A*)operator new(sizeof(A));
    25. 	new(p)A; // new(p)A(3);  // 定位new，placement-new，显示调用构造函数初始化这块对象空间
    26.  
    27. 	// 等于 delete p
    28. 	p->~A(); // 析构函数可以显示调用
    29. 	operator delete(p);
    30.  
    31. 	return 0;
    32. }

     7. 常见面试题

    7.1 malloc/free和new/delete的区别（使用上）

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

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

    7.2 内存泄漏

    7.2.1 什么是内存泄漏，内存泄漏的危害

            什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

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

     

    7.2.2 内存泄漏分类（了解）

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

    • 堆内存泄漏(Heap leak)

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

    • 系统资源泄漏

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

    7.2.3 如何避免内存泄漏

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

    总结：

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

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

    7.3 如何一次在堆上申请4G的内存？

    1. // 将程序编译成x64的进程，运行下面的程序试试？
    2. #include <iostream>
    3. using namespace std;
    4. int main()
    5. {
    6.  void* p = new char[0xfffffffful];
    7.  cout << "new:" << p << endl;
    8.  return 0;
    9. }

            其实很简单，就是将编译器换成x64的进程。

            x86是32位的机器，总共有2^32大小的空间，也就是4个G，但堆只占2G左右。

            x64是64位机器，总共有2^64大小的空间，我算了一下，大概是160亿多个G的空间，这是相当大的内存，但是这只是虚拟内存空间，和你电脑上的内存有很大的差别哦，这个概念以后再给大伙介绍~

            如上就是C++内存管理的所有知识，接下来本专辑会更新模板初阶，带大家走入STL模板库的大家庭，如果大家喜欢看此文章并且有收获，可以时刻关注我，本专栏持续更新！

            感谢大家观看，感谢大家支持！

  • 相关阅读:
    Spring Cloud项目（六）——使用sentinel作为流控管理
    Hadoop入门介绍
    RestTemplate：简化HTTP请求的强大工具
    【网页前端】HTML表格、图片、列表、超链接以及综合案例练习
    2018-2022年盟浪 ESG数据
    English语法_形容词/副词3级-比较级_常用短语
    移动端手指事件和手机事件：
    【无标题】
    025: vue父子组件中传递方法控制：$emit,$refs,$parent,$children
    Python学习基础笔记七十三——调试程序
  • 原文地址：https://blog.csdn.net/weixin_69725192/article/details/125385057