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

文章目录

• • 一、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