C++中的内存管理

最新推荐文章于 2024-08-21 22:18:43 发布

c code

最新推荐文章于 2024-08-21 22:18:43 发布

阅读量1.5k

点赞数 30

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/kk6kk/article/details/136435637

版权

文章目录

1. C/C++内存分布

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

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

4. operator new与operator delete函数

5. new和delete的实现原理

6. 定位new表达式(placement-new)

7.一些常见的问题和有关内存泄漏的知识

1、C/C++内存分布

我们先来看下面的一段代码和相关问题

#include <stdlib.h>
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);
}
//选择题：
//选项: A.栈  B.堆  C.数据段(静态区)  D.代码段(常量区)
//     globalVar在哪里？__C__   staticGlobalVar在哪里？__C__
//     staticVar在哪里？__C__   localVar在哪里？__A__
//     num1 在哪里？__A__ 
//     char2在哪里？__A__       *char2在哪里？__A__ 
//注意："abcd"是在常量区，但是char2是在栈上的，char2在栈上依据"abcd"的大小开了块空间，
//然后"abcd"拷贝了一份存到了这里，
//所以，*char2表示的是这个拷贝过来的这一份"abcd"的首元素'a'，所以是在栈上的。
//     pChar3在哪里？__A__      *pChar3在哪里？__D__ 
//注意：pChar3是在栈上的一个指针，指向的空间(*pChar3)在常量区
//     ptr1在哪里？__A__        *ptr1在哪里？__B__ 
//注意：ptr1是在栈上的一个指针，指向的空间(*ptr1)在堆上

【说明】

1.内核空间用户代码不能读写

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

3.内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。

用户可使用系统接口创建共享共享内存，做进程间通信。

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

5.数据段--存储全局数据和静态数据。 --从C、C++语言的角度也喜欢把数据段叫做静态区

--数据段的叫法是从操作系统的角度来说的

6.代码段--可执行的代码/只读常量。 --从C、C++语言的角度也喜欢把代码段叫做常量区

--代码段的叫法是从操作系统的角度来说的

补充一些问题：

1、为什么C/C++要有这些程序内存区域的划分？

答：为了方便管理各种不同类型的数据

2、这些区域中哪个区域是要我们重点关注的？

答：堆。因为想要在堆上定义变量需要你先去申请空间，需要你进行管理，还需要你主动去释放，避免内存泄漏。 --其他几个区要么你管不了(比如内核空间)，要么你可以不需要太注意管(比如栈，你只管定义变量只管用就好)

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

举个栗子：

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(p3);
    //这里需要free(p2)吗？
    //答：不需要，首先realloc分为原地扩容和异地扩容，
    //如果是原地扩容的话free(p3)就够了(而且你再去释放p2会报错(同一块空间多次释放))，
    //如果是异地扩容的话且扩容成功的情况下，realloc会帮助你把原本的空间给释放掉，
    //不需要你再去释放了(你也不能再去释放)。
}

补充两个问题：

1. malloc/calloc/realloc的区别？

答：malloc和calloc功能差不多，都是在堆上开辟出一块空间，但是calloc会将开辟的空间进行初始化(初始化为0)，而malloc不会。realloc的作用有两个，一个跟malloc的效果一样，就是realloc也能用来在堆上开辟空间，但realloc的主要作用还是对malloc/calloc/realloc所动态开辟出的空间的空间大小进行调整。注：malloc、calloc、realloc开辟空间/调整空间大小失败都会返回NULL。

(以上都是本人自己的理解，有不足之处请指出)

2. malloc的实现原理？

答：原理挺复杂的，本人也不是很懂，但想了解的可以点击下面的链接去看

【CTF】GLibc堆利用入门-机制介绍_哔哩哔哩_bilibili

3、C++内存管理方式

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

因此C++又提出了自己的内存管理方式：

通过new和delete操作符(注意它们是操作符，不是函数，它们在编译时就会被转化成各种指令)进行动态内存管理。

3.1 new和delete操作内置类型

举个栗子：

int main()
{
    动态申请1个int类型的空间 //优点1：写法更简洁了
    int* ptr1 = new int; //默认是不初始化的
  
    //动态申请一个int类型的空间并初始化为10
    int* ptr2 = new int(10);
  
    //动态申请10个int类型的空间
    int* ptr3 = new int[10];

    //动态申请10个int类型的空间并初始化 //优点2：可以控制要初始化几个，C语言的不行
    int* ptr4 = new int[10]{1,2,3,4,5}; //C++11开始支持这样初始化，这边只给了前5个值，后五个编译器会自动用0去初始化(有点像数组的初始化，没给的自动用0初始化)

    delete ptr1;
    delete ptr2;
    delete[] ptr3;
    delete[] ptr4;

    return 0;
}
//注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]，注意：匹配起来使用。

3.2 new和delete操作自定义类型

举个栗子：

struct ListNode
{
    ListNode* _next;
    int _val;

    ListNode(int val)
        :_next(nullptr);
        ,_val(val);
    {}
};
struct ListNode* CreateListNode(int val) //以前C语言创建一个结点的做法
{
    struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
    if(!newnode)
    {
        //...
    }

    newnode->next = NUll;
    newnode->val = val;

    return newnode;
}
ListNode* CreateList(int n) //假设要创建一个长度为n的链表，用C++的方式
{
    ListNode head(-1); //哨兵位，不然下面还需要判空
    int val;
    ListNode* tail = &head; //尾指针
    printf("请依次输入%d个结点的值：",n); //注：这里用C语言的printf方便点，用cout还有分几段进行打印
    for(int i = 0;i < n;i++)
    {
        cin >> val;
        tail->_next = new ListNode(val); //进行尾插
        tail = tail->_next;
    }

    return head.next;
}
int main()
{
    //对于自定义类型，new不仅会靠空间还会去调用它的构造函数，malloc则不会
    ListNode* node1 = new ListNode(1);
    ListNode* node2 = new ListNode(2);
    ListNode* node3 = new ListNode(3);
    //...
    //注：而且new失败了以后编译器会抛异常(后面会学try catch来处理这个抛异常)，不需要我们再手动检查了(优点4)

    //对于自定义类型，delete则会去调用它的析构函数，free则不会
    delete node1;
    delete node2;
    delete node3;

    ListNode* list1 = CreateList(5);

    return 0;
}
//注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。(优点3)

4、operator new与operator delete函数

4.1 operator new与operator delete函数

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

operator new 和operator delete是系统提供的全局函数，

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

operator new和operator delete的代码：

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；
              申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。
*/
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc) //如果你想用这个函数也能用，它跟malloc的用法一样。ex：int* p=(int*)operator new(10*4);
{
// try to allocate size bytes
void *p;
while ((p = malloc(size)) == 0)
比特就业课
通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果
malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施
就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
5. new和delete的实现原理
5.1 内置类型
     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来申请空间，(operator new就是对malloc的一个封装)

如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。

operator delete 最终是通过free来释放空间的。

5、new和delete的实现原理

5.1 内置类型

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

new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

5.2 自定义类型

new的原理 --先去申请空间，再去调用构造 --new的底层是operator new(抛异常在operator new里面) + 构造函数 --operator new的底层是malloc

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

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

delete的原理 --先调用析构，再去释放 --因为new先申请了空间，这时候再去调用构造，构造里面也可能有申请空间；如果先进行释放，释放的是new申请的空间，那这时候就没办法再去调用析构了，就出现了内存泄漏

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

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

new T[N]的原理 --new[]的底层是operator new[] + n次构造函数 --operator new[]的底层是operator new --operator new的底层是malloc

1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请

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

delete[]的原理

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

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

补充：(new和delete的一些底层原理)

int main()
{
    //假设A的大小是4byte(且你有显示写析构函数，A里只有一些内置类型的成员变量)
    A* ptr1 = new A; //调用1次operator new + 1次构造函数 --这边编译器会给你开 4byte 的空间
    delete ptr1; //调用1次析构函数 + 1次operator delete

    A* ptr2 = new A[10]; //调用1次operator new[] + 10次构造函数 --理论上编译器应该给你开 40byte 的空间，但实际上编译器会给你开 44byte 的空间
    //为什么呢？
    //答：因为delete的时候是它不知道要调用几次析构函数，上面的new是因为后面的[]里面写了10，它知道要调用10次构造，但下面的delete的[]里可啥都没写
    delete[] ptr2; //调用?次析构函数 + 1次operator delete[]
    //所以：为了让delete知道要调用几次析构函数，就在开空间时在要开的 40byte 的空间前面多开 4byte 的空间用来存那个对象个数(这里是10)
    //注：ptr2指向的位置是要开的  40byte 的空间的起始位置，并不是前面用来存那个对象个数的那块空间的起始位置。

    //注：但也不是什么情况都会多开 4byte 的空间，关键看需不需要。
    //ex：
    int* p = new int[10]; //这边编译器会给你开 40byte 的空间
    delete[] p;
    //原因：这种情况它就不会多开 4byte 的空间，因为这是内置类型没有去调析构函数。
    //再ex：假设B的大小是4byte(且你没有显示写析构函数，B里只有一些内置类型的成员变量)
    B* ptr2 = new B[10]; //这边编译器会给你开 40byte 的空间
    //原因：因为这边你没显示写析构函数，
    //      所以VS编译器会生成默认的析构函数，
    //      但VS编译器发现这默认生成的析构函数也不需要做什么事，
    //      那么VS编译器就会给它优化掉，干脆就不去调了，
    //于是：也就不需要那个个数了。
    //但是：如果你显示写了析构函数，即使你显示写的析构函数里面也是什么都没做，但编译器也是不敢去优化的，它还是会去调，这时候就需要个数了。

    return 0;
}

补充：operator new[]和operator new的区别：operator new[]可能会多开 4byte 的空间去存对象个数(这取决与后面delete[]需不需要)，operator new则不会。

注：编译器会不会去调用那个默认生成的析构函数，这还取决于编译器自身，看它的优化程度。

补充：(new和delete的一些奇奇怪怪的现象)

假设 new 和 delete 没有匹配使用

int main()
{
    //这会有什么问题吗？
    int* p1 = new int[10];
    delete p1;
    //这会有什么问题吗？
    //答：不会，从底层看可知这里就是调用1次operator new + 1次operator delete

    //这会有什么问题吗？
    A* p2 = new A[10];
    delete p2;
    //答：可能会出现内存泄漏，因为这里是调用10次构造函数 + 1次析构函数 + 1次operator new + 1次operator delete
    //    如果构造函数里没有再去申请空间还好，如果有，那么就是出现了内存泄漏
    //但是：内存泄漏还可能只是其中的一个问题(因为内存泄漏不会报错)，这里会直接运行崩溃(这里有个前提是你有显示写析构函数，你没写的话就没啥事了)。
    //原因：这里的delete释放的位置错了。
    //      这里的delete释放是从这段开出来的那块空间(44byte)的起始位置 4byte 用来存对象个数的那块空间的后面，40byte 空间的起始位置进行释放的，这是不行的，
    //      因为free只能从最初的位置开始一口气全部free，不能从中间free个一部分啥的
    //注：用delete[]就不会错了，因为delete[]在最后析构完之后，会把指针往前偏移 4byte 再去释放。(delete则不会将指针进行偏移)
    //注：你没显示写析构函数也不会报错的原因是：VS编译器没有去开前面的那 4byte 空间，自然也就不会出现释放位置错误的原因了。

    return 0；
}

总结：一定要匹配使用 new 和 delete，不然可能会出现各种奇奇怪怪的错误。

6. 定位new表达式(placement-new)

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

使用格式：

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

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

使用场景：

定位new表达式在实际中一般是配合内存池使用！！

因为内存池分配出的内存(从内存池申请的空间，后面释放也是释放回给内存池)没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

举个栗子：

class A
{
public:
    A(int a = 0)
        : _a(a)
    {
        cout << "A():" << this << endl;
    }
    ~A()
    {
        cout << "~A():" << this << endl;
    }
private:
    int _a;
};
int main()
{
    //p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
    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;
}

注：现实当中一般情况下不会这样用的，真是多此一举，这就是把 new 和 delete 拆成几步来用，效果跟直接用 new 和 delete 一样，何必呢。