小工具知识网

当前位置: 首页 > 行业知识 > 【C++】C/C++内存管理详解

行业知识

【C++】C/C++内存管理详解

2026-11-16 15:57:57 来源:互联网转载

个人主页 : zxctscl

���章封面来自:艺术家–贤海林

如有转载请先通知

目录

  • 1. 前言
  • 2. C/C++内存分布
  • 3. C语言中动态内存管理方式
  • 4. C++中动态内存管理
    • 4.1 new/delete操作内置类型
    • 4.2 new和delete操作自定义类型
    • 5. operator new与operator delete函数
      • 5.1 operator new与operator delete函数
      • 6. new和delete的实现原理
        • 6.1 内置类型
        • 6.2 自定义类型
        • 7. 定位new表达式(placement-new)
        • 8. 常见面试题
          • 8.1 malloc/free和new/delete的区别
          • 8.2 内存泄漏
          • 8.2.1 什么是内存泄漏,内存泄漏的危害
          • 8.2.2 内存泄漏分类
          • 8.2.3 如何检测内存泄漏
          • 8.2.4 如何避免内存泄漏

            1. 前言

            在之前的C语言中就有提到动态内存管理 【C语言】动态内存管理,那么在C++中又是怎么样的呢?话不多说,正文开始。

            2. 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.代码段(常量区)

            (1) globalVar在哪里?

            C 全局变量在静态区

            (2) staticGlobalVar在哪里?

            C 全局的静态的是在在静态区

            (3)staticVar在哪里?

            C 局部的静态也是在静态区

            (4)localVar在哪里?

            A 在栈帧里面

            (5) num1 在哪里?

            A 数组名代表的是整个数组,存在栈上

            (6)char2在哪里?

            A char2的意思是有abc\0字符串,在栈上开辟一个数组,然后把这个字符串拷贝过去。

            char2是一个字符数组,它是数组名代表的是整个数组,存在栈上。

            (7)* char2在哪里?

            A * char2解引用的时候这个char2在栈上。

            (8) pChar3在哪里?

            A const修饰的并不代表它就是在常量区,pChar3是栈上的一个指针变量,它指向abcd这个字符串。pChar3在栈上。

            (9) * pChar3在哪里?

            D * pChar3在常量区

            (10) ptr1在哪里?

            A ptr1同样是栈上的一个指针变量,指向堆上的一块空间。

            (11) * ptr1在哪里?

            B 是malloc出来空间首元素的地址给了 *ptr1,所以*ptr1在堆上。

            1. 填空题:

            sizeof(num1) =40

            求的是这个数组的 sizeof,int占4个字节,这里数组中10个,就是10*4

            sizeof(char2) = 5

            也是sizeof数组名,计算整个数组的大小

            strlen(char2) = 4

            strlen计算的是字符串大小,遇到\0就结束

            sizeof(pChar3) = 4/8

            pChar3是指针,指针的大小和平台有关系,在64位下就是8,32位下就是4

            strlen(pChar3) = 4

            遇到\0就结束

            sizeof(ptr1) = 4/8

            ptr1是指针,指针的大小和平台有关系,在64位下就是8,32位下就是4

            分这些区域就是为了方便管理。

            而堆是我们重点关注的。

            【说明】

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

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

            C语言动态内存管理重点关注的就是:malloc/calloc/realloc/free

            void Test(){int* p1 = (int*)malloc(sizeof(int));free(p1);int* p2 = (int*)calloc(4, sizeof(int));int* p3 = (int*)realloc(p2, sizeof(int) * 10);// 这里需要free(p2)吗?free(p3);}

            这里需要free(p2)吗?

            不需要,这里的realloc有原地扩容和异地扩容。原地扩容和p2指向的空间是同一个。异地扩容时候,p2已经释放掉了,free(p3)就行。

            动态内存管理详细可以看看 【C语言】动态内存管理

            4. C++中动态内存管理

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

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

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

            4.2 new和delete操作自定义类型

            与c语言相比较的动态内存管理相比较:

            1、用法上,变简洁了

            2、可以控制初始化

            int* p3 = new int(10); // new 1个int对象,初始化成10int* p4 = new int[10] { 1, 2, 3, 4, 5 };//这里new 10个int对象,没写完默认用0初始化

            3、自定义类型,开空间+构造函数

            在之间c语言中我们写数据结构的节点,得写一个创建节点的函数CreateListNode

            struct ListNode{ListNode* _next;int _val;};struct ListNode* CreateListNode(int val){struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));if (newnode == NULL){perror("malloc fail");return NULL;}newnode->_next = NULL;newnode->_val = val;return newnode;}

            而在C++里面把构造函数写好了,就自动调用构造函数:

            struct ListNode{ListNode* _next;int _val;ListNode(int val):_next(nullptr), _val(val){}};ListNode* node1 = new ListNode(1);ListNode* node2 = new ListNode(2);ListNode* node3 = new ListNode(3);

            4、new失败了以后抛异常,不需要手动检查

            在之后会提到抛异常。请多多关注。

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

            5. operator new与operator delete函数

            5.1 operator new与operator delete函数

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

            /*operator new:该函数实际通过malloc来申请空间,当malloc申请空间成功时直接返回;申请空间失败,尝试执行空               间不足应对措施,如果改应对措施用户设置了,则继续申请,否则抛异常。*/void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc){// try to allocate size bytesvoid* 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来释放空间的。

            但如果我们要用operator new的话和malloc用法是一样的。

            int* p1 = (int*)operator new(10 * 4);
            class A{public:A(int a = 0): _a(a){cout cout A* ptr = new A; return 0;}public:Stack(){_a = (int*)malloc(sizeof(int) * 4);_top = 0;_capacity = 4;}~Stack(){free(_a);_top = _capacity = 0;}private:int* _a;int _top;int _capacity;};int main(){Stack* pst = new Stack;delete pst;return 0;}public:A(int a = 0): _a(a){cout A* ptr1 = new A; // operator new + 1次构造A* ptr2 = new A[10];// operator new[] + 10次构造delete ptr1; // 1次析构 + operator deletedelete[] ptr2; // 10次析构 + operator delete[]int* p1 = new int[10];return 0;}public:A(int a = 0): _a(a){cout cout A* p1 = (A*)malloc(sizeof(A));//显示调用构造函数对一块已经有的空间初始化new(p1)A;  // 注意:如果A类的构造函数有参数时,此处需要传参p1-~A();free(p1);A* p2 = (A*)operator new(sizeof(A));new(p2)A(10);p2-~A();operator delete(p2);return 0;}// 1.内存申请了忘记释放int* p1 = (int*)malloc(sizeof(int));int* p2 = new int;// 2.异常安全问题int* p3 = new int[10];Func(); // 这里Func函数抛异常导致 delete[] p3未执行,p3没被释放.delete[] p3;}

上一篇:模拟器下载指南,简单步骤教你获取模拟器

下一篇:ibm服务器怎么组建raid?