C/C++内存管理学习【new】

慈云数据 2024-03-20 技术支持 51 0

文章目录

    • 一、C/C++内存分布
    • 二、C语言中动态内存管理方式:malloc/calloc/realloc/free
    • 三、C++内存管理方式
      • 3.1 new/delete操作内置类型
      • 3.2 new和delete操作自定义类型
      • 四、operator new与operator delete函数
      • 五、new和delete的实现原理
        • 5.1 内置类型
        • 六、定位new表达式(placement-new)
        • 七、常见面试题
          • 7.1 内存泄漏
          • 7.2 内存泄漏分类
          • 7.3 如何检测内存泄漏
          • 7.4 如何避免内存泄漏

            一、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在哪里?C
              • staticGlobalVar在哪里?C
              • staticVar在哪里?C
              • localVar在哪里?A
              • num1 在哪里?A
                • char2在哪里?A
                  • 字符串在常量区,char2会栈上开辟一个数组,然后将常量区的字符串拷贝过到栈上,所以结果是A,上题的num1是直接在栈上开辟的,所以相似
                  • *char2在哪里?A
                    • 这个上题说过了不讲了
                    • pChar3在哪里?A
                      • const修饰的是代表常变量,不代表就在常量区,pChar3是栈上的一个变量,指向了常量区的字符串
                      • *pChar3在哪里?D
                        • 常量区的字符串,解引用就是找的常量区
                        • ptr1在哪里?A
                          • 也是栈上的一块变量
                          • *ptr1在哪里?B
                            • 开辟的空间在堆上
                              1. 填空题:
                              • sizeof(num1) = 40;
                              • sizeof(char2) = 5;
                              • strlen(char2) = 4;
                              • sizeof(pChar3) = 4/8;
                              • strlen(pChar3) = 4;
                              • sizeof(ptr1) = 4/8;
                                1. sizeof 和 strlen 区别?
                                • 这里具体可以移步到C语言指针章节,最后面有详细的讲解

                                  在这里插入图片描述

                                  【说明】

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

                                  • 为什么要分这些区域

                                    • 为了方便管理,程序中有各种不同的数据
                                    • 这些区域哪个区域是我们需要重点关注的?

                                      • 堆【堆留给我们自己自主控制的】

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

                                        【面试题】

                                        • malloc/calloc/realloc的区别?

                                          • malloc是在内存中直接开辟一块空间
                                          • calloc会在开辟的时候进行初始化【初始化成0】
                                          • realloc可以进行已开辟的空间进行扩容

                                            三、C++内存管理方式

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

                                              3.1 new/delete操作内置类型

                                              void Test()
                                              {
                                              	// 动态申请一个int类型的空间
                                              	int* ptr4 = new int;
                                              	// 动态申请一个int类型的空间并初始化为10
                                              	int* ptr5 = new int(10);
                                              	// 动态申请10个int类型的空间
                                              	int* ptr6 = new int[3];
                                              	delete ptr4;
                                              	delete ptr5;
                                              	delete[] ptr6;
                                              }
                                              

                                              在这里插入图片描述

                                              在这里插入图片描述

                                              • new10个对象进行初始化,后面跟上大括号进行即可
                                                int* p2 = new int[10] {1, 2, 3, 4, 5, 6, 7};	
                                                

                                                在这里插入图片描述

                                                • 这里要一定注意,要匹配着使用

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

                                                  3.2 new和delete操作自定义类型

                                                  class A
                                                  {
                                                  public:
                                                  	A(int a = 0)
                                                  		: _a(a)
                                                  	{
                                                  		cout 
                                                  		cout 
                                                  	// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
                                                  	A* p1 = (A*)malloc(sizeof(A));
                                                  	A* p2 = new A(1);
                                                  	free(p1);
                                                  	delete p2;
                                                  	
                                                  	// 内置类型是几乎是一样的
                                                  	int* p3 = (int*)malloc(sizeof(int)); // C
                                                  	int* p4 = new int;
                                                  	free(p3);
                                                  	delete p4;
                                                  	
                                                  	A* p5 = (A*)malloc(sizeof(A) * 10);
                                                  	A* p6 = new A[10];
                                                  	free(p5);
                                                  	delete[] p6;
                                                  	
                                                  	return 0;
                                                  }
                                                  
                                                  	ListNode* _next;
                                                  	int _val;
                                                  	ListNode(int val)
                                                  		:_next(nullptr)
                                                  		, _val(val)
                                                  	{}
                                                  };
                                                  // 创建的不带哨兵位
                                                  ListNode* CreateList(int n)
                                                  {
                                                  	ListNode head(-1);  // 哨兵位
                                                  	ListNode* tail = &head;
                                                  	int val;
                                                  	printf("请依次输入%d个节点的值:", n);
                                                  	for (int i = 0; i 
微信扫一扫加客服

微信扫一扫加客服

点击启动AI问答
Draggable Icon