C++-内存管理

2024年7月 · 预计阅读时间： 4 分钟

编程语言 c++

C/C++内存分布

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

C++中动态内存管理

operator new 与 operator delete 函数

new 和 delete 的实现原理

定位 new 表达式(placement-new)

面试题

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";
    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
static GlobalVar 在哪里？C
staticVar 在哪里？C
localVar 在哪里？A
num1 在哪里？A
char2 在哪里？A
*char2 在哪里？A char2 是一个数组，其成员在函数栈里面
pChar3 在哪里？A pChar3 是一个指针变量，在函数的栈上
*pChar3 在哪里？C 解引用的是字符常量，存储在常量区，即数据段上
ptr1 在哪里？A
*ptr1 在哪里？B
填空题：
sizeof(num1) = 40
sizeof(char2) = 5; strlen(char2) = 4;
sizeof(pChar3) = 4 或 8; strlen(pChar3) = 4;
sizeof(ptr1) = 4 或 8;

总结：

栈：存储非静态局部变量、函数参数、返回值等，向下增长
堆：用于程序运行时动态分配内存，向上增长
内存映射段：高效 IO 映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信。
数据段：存储全局数据和静态数据
代码段：存储代码，包括用户代码和系统初始化代码

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

malloc/calloc/realloc 和 free#

void Test ()
{
    int* p1 = (int*) malloc(sizeof(int));
    free(p1);
    malloc/calloc/realloc的区别？
    // 1.malloc/calloc/realloc的区别是什么？
    int* p2 = (int*)calloc(4, sizeof (int));
    int* p3 = (int*)realloc(p2, sizeof(int)*10);

    // 这里需要free(p2)吗？不需要因为在realloc的时候已经释放了
    free(p3 );
}

malloc/calloc/realloc 的区别？

简单来说：
malloc 用于分配共 size 字节内存但不初始化。
calloc 用于分配num 块 size 字节大小内存并将其初始化为零。
realloc 用于调整已分配内存的大小。
具体而言：
malloc（Memory Allocation）：
功能：分配一块指定大小的内存区域。
语法：void* malloc(size_t size);
参数：size 是需要分配的字节数。
返回值：返回一个指向分配内存的指针，如果分配失败则返回 NULL。
特点：分配的内存区域的内容是不初始化的，可能包含垃圾值。
calloc（Contiguous Allocation）：
功能：分配一块内存并初始化为零。
语法：void* calloc(size_t num, size_t size);
参数：
num 是需要分配的元素个数。
size 是每个元素的字节数。
返回值：返回一个指向分配并初始化为零的内存的指针，如果分配失败则返回 NULL。
特点：分配的内存区域会被初始化为零。
realloc（Reallocation）：
功能：调整之前分配的内存块的大小。
语法：void* realloc(void* ptr, size_t new_size);
参数：
ptr 是指向之前分配内存的指针。
new_size 是新的内存大小。
返回值：返回一个指向新内存块的指针。如果重新分配失败，则返回 NULL，原有内存块保持不变。
特点：
如果 new_size 大于原来的内存块大小，会将数据复制到新的内存块；
如果 new_size 小于原来的大小，原有数据会被截断。原有的内存块会被释放，或者在失败时保持不变。

C++中动态内存管理#

通过 new 和 delete 操作符进行动态内存管理。

申请和释放单个元素的空间，使用 new 和 delete 操作符，申请和释放连续的空间，使用 new[]和 delete[]。

new 和 delete 操作自定义类型：在申请自定义类型空间时，new 会调用构造函数，delete 会调用析构函数。

class Test
{
public:
    Test()
        : _data(0)
    {
        cout<<"Test():"<<this<<endl;
    }
    ~Test()
    {
        cout<<"~Test():"<<this<<endl;
    }

private:
    int _data;
};
void Test2()
{
    // 申请单个Test类型的空间
    Test* p1 = (Test*)malloc(sizeof(Test));
    free(p1);

    // 申请10个Test类型的空间
    Test* p2 = (Test*)malloc(sizoef(Test) * 10);
    free(p2);
}

void Test2()
{
    // 申请单个Test类型的对象
    Test* p1 = new Test;
    delete p1;

    // 申请10个Test类型的对象
    Test* p2 = new Test[10];
    delete[] p2;
}

operator new 与 operator delete 函数#

注意这两个是函数，而 new 和 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 bytes
    void *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 与 operator delete 的类专属重载，比如在链表类中，使用内存池，提高效率

new 和 delete 的实现原理#

对于内置类型#

如果申请的是内置类型的空间，new 和 malloc,delete 和 free 基本类似，

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

对于自定义类型#

new
- 调用 operator new 函数申请空间，实际又去调用了 malloc 函数
- 在申请的空间上执行构造函数，完成对象的构造
delete
- 在空间上执行析构函数，完成对象中资源的清理工作
- 调用 operator delete 函数释放对象的空间，实际调用 free
new type[N]
- 调用 operator new[]函数，在 operator new[]中实际调用 operator new 函数完成 N 个对象空间的申请
- 在申请的空间上执行 N 次构造函数
delete[]
- 在释放的对象空间上执行 N 次析构函数，完成 N 个对象中资源的清理
- 调用 operator delete[]释放空间，实际在 operator delete[]中调用 operator delete 来释放空间

placement-new 表达式#

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

使用格式：

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

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

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

示例：

面试题#

1.malloc/free 和 new/delete 的区别

概念性质：malloc 是一个函数、new 是一个操作符；
使用方法：malloc 传入的是字节数，返回值是 void*
new 后面跟着的是申请对象的类型，返回的是类型的指针；
使用效果：malloc 失败了返回空指针 NULL(0)
new 会调用构造函数，失败抛异常

2.什么是内存泄漏，它的危害是什么？

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
如何避免：
工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要智能指针来管理才有保证。
采用 RAII 思想或者智能指针来管理资源。
有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

3.如何一次在堆上申请 4G 的空间

将程序编译成 64 位，这样内存空间理论大小是 2^64；
而 32 位程序只有 2^32=4GB 的内存。

近期文章