C++内存管理

本篇目标：

1.知晓C++的内存分布；

2.学会C++内存管理方式；

3.了解new和delete的底层实现原理

一.C/C++内存管理

1.C/C++内存分布

#include <iostream>

using namespace std;

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

int main()
{
	Test();
	return 0;
}

问题:

选择题：
选项: A.栈  B.堆  C.数据段(静态区)  D.代码段(常量区)
<1>.globalVar在哪里？____   
<2>.staticGlobalVar在哪里？____
<3>.staticVar在哪里？____   
<4.localVar在哪里？____
<5>.num1 在哪里？____
<6>.char2在哪里？____       
<7>.*char2在哪里？___
<8>.pChar3在哪里？____      
<9>.*pChar3在哪里？____
<10>.ptr1在哪里？____        
<11>.*ptr1在哪里？____

解释：

<1>.全局变量globalVar的生命周期贯穿整个程序运行过程，不属于某个函数栈帧，所以放在静态存储区 。因为它还被显式初始化为 1，更细地说通常位于 .data 段。

<2>.staticGlobalVar虽然多了 static，但它仍然具有静态存储期 ，所以还是在数据段（静态区）。这里 static 主要改变它的链接属性，不会让它跑到栈里。

<3>.虽然staticVar写在 Test() 函数内部，但因为有 static，它不是普通局部变量 。它只初始化一次 ，并且生命周期贯穿整个程序 ，所以也在：C. 数据段（静态区）。

<4>.localVar是普通局部变量，调用 Test() 时创建，函数结束后销毁，所以通常放在：A. 栈。

<5>.虽然num1是数组，但它仍然是函数内部定义的普通局部变量，没有 static，所以整个数组空间都在：A. 栈。

<6>char2 是一个局部字符数组，内容是拷贝处于常量区的"abcd"，而数组本身开在 Test() 的栈帧里 ，所以：char2 是在 栈上的。

<7>.char2代表的是数组首元素的地址 ，*char2 表示也就是这个数组里的第一个字符 'a'，既然 char2 整个数组都在栈上，那么它里面的元素当然也在栈上。

<8>.pChar3 是一个局部指针变量 ，它定义在 Test() 函数内部，所以：pChar3 → A. 栈

但是它保存的地址指向字符串常量"abcd"， 这个字符串常量通常存放在只读常量区，所以:

<9>.*pChar3 表示 pChar3 指向的第一个字符，也就是 'a'，它属于字符串常量 "abcd" 的内容 ，因此：*pChar3 → D. 代码段（常量区）。

<10>.ptr1 本身是一个局部指针变量，定义在 Test() 函数里，所以：ptr1 → A. 栈。

<11>.但是 malloc 开出来的那一块内存是在堆上的，所以 ptr1 指向的是堆空间。因此：*ptr1 → B. 堆。

如图所示：

说明 ：

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

2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口 创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）

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

4. 数据段--存储全局数据和静态数据。

5. 代码段--可执行的代码/只读常量。

2.C++内存管理

2.1.C语言内存管理方式

<1>.malloc：申请一块连续内存，但不初始化内容。

int* p = (int*)malloc(sizeof(int) * 10);

表示申请能放 10 个 int 的空间。

特点：

• 返回的是一块连续堆空间的首地址
• 里面原来的值是未定义的
• 申请失败返回 NULL

<2>.calloc：也是申请连续内存，但会把申请出来的内存初始化为 0。

int* p = (int*)calloc(10, sizeof(int));

表示申请 10 个 int。

和 malloc 的核心区别：

malloc：只申请，不清零
calloc：申请 + 清零

<3>.realloc：调整一块已经申请过的动态内存大小。

p = (int*)realloc(p, sizeof(int) * 20);

意思是把原来的空间调整到能放 20 个 int。

它有两种情况：

1. 原位置后面空间够，直接在原来的位置扩展(原地扩容)
2. 原位置后面空间不够，重新找一块更大的空间，把原数据拷过去，再释放旧空间(异地扩容)

所以 realloc 返回的新地址可能和原地址一样，也可能不一样。

这里最好别直接这么写：

p = realloc(p, newSize);

因为如果失败返回 NULL，原来的地址可能就丢了。

更稳妥：

int* tmp = realloc(p, newSize);

if(tmp != NULL)
{
    p = tmp;
}

<4>.free：释放通过 malloc / calloc / realloc 申请的堆空间。

free(p);

释放之后，最好：

p = NULL;

这样可以避免野指针。

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

2.2.C++内存管理方式

2.2.1.new/delete操作内置类型

例子演示：

#include <iostream>

using namespace std;

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

int main()
{
    Test();
	return 0;
}

演示结果：

如果我们想给用new出来的数组初始化，也可以这样做：

int* ptr7=int new[10]{1,2,3};

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

对于内置类型，malloc和new的几乎都是一样的，可如果是自定义类型呢?

2.2.2.new和delete操作自定义类型

例如，我们有这么一个类：

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
        cout << "~A():" << this << endl;
	}
private:
	int _a;
};

这个构造函数我们都知道是默认构造函数，用malloc也是可以成功的，例如:

A* p1 = (A*)malloc(sizeof(A));

解释：malloc**在堆上申请一块大小等于 sizeof(A) 的原始内存，然后把这块内存的地址强转成 A*,但是**它是不会执行构造函数的，所以p1里面的_a的初始值就不是构造函数里面的默认值，而是随机值。

A(int a = 0)

如果是用new和delete就比较简单了，例如：

int main()
{
	// 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;
}

输出结果：

可以看出：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与 free不会。

2.3.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 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);  // 阻塞其他线程

    __TRY
        // 获取内存块头部指针
        pHead = pHdr(pUserData);

        // 检查内存块类型是否合法
        _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));

        // 释放内存
        _free_dbg(pUserData, pHead->nBlockUse);

    __FINALLY
        _munlock(_HEAP_LOCK);  // 释放堆锁
    __END_TRY_FINALLY

    return;
}

/*
 * free 的实现
 */
#define free(p) _free_dbg(p, _NORMAL_BLOCK)

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间 ，如果 malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施 就继续申请，否则就抛异常；operator delete 最终是通过free来释放空间的。

2.4.new和delete的实现原理

<1>内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是： new/delete申请和释放的是单个元素的空间，new\[\]和delete\[\]申请的是连续空间，而且new在申 请空间失败时会抛异常，malloc会返回NULL。

<2>.自定义类型

1.new的原理:

调用operator new函数申请空间 ；在申请的空间上执行构造函数，完成对象的构造。

2.delete的原理：

先在空间上执行析构函数，完成对象中资源的清理工作；调用operator delete函数释放对象的空间。

3.new TN的原理：

调用operator new\[\]函数，在operator new\[\]中实际调用operator new函数完成N个对 象空间的申请， 在申请的空间上执行N次构造函数。

4.delete\[\]的原理：

在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理；调用operator delete\[\]释放空间，实际在operator delete\[\]中调用operator delete来释放空间。

2.5.定位new表达式

使用：

// 定位 new / placement new
int main()
{
    // p1 现在指向的只是一段与 A 对象大小相同的空间，
    // 还不能算是真正的 A 对象，因为构造函数还没有执行。
    A* p1 = (A*)malloc(sizeof(A));

    // 在 p1 指向的这块已有空间上构造 A 对象。
    // 如果 A 的构造函数有参数，这里需要传参。
    new(p1) A;

    // 显式调用析构函数。
    p1->~A();

    // 释放 malloc 申请的原始内存。
    free(p1);

    // 使用 operator new 只申请原始内存，不调用构造函数。
    A* p2 = (A*)operator new(sizeof(A));

    // 在 p2 指向的空间上构造 A 对象，并传入参数 10。
    new(p2) A(10);

    // 显式调用析构函数。
    p2->~A();

    // 释放 operator new 申请的原始内存。
    operator delete(p2);

    return 0;
}

流程：

malloc / operator new
        ↓
只申请原始内存

placement new
        ↓
在已有内存上调用构造函数

显式调用析构函数
        ↓
p->~A()

free / operator delete
        ↓
释放原始内存

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

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地 方是：

<1>. malloc和free是函数，new和delete是操作符

<2>. malloc申请的空间不会初始化，new可以初始化

<3>. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可， 如果是多个对象，\[\]中指定对象个数即可

<4>. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型

<5>. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需 要捕获异常

<6>. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new 在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成 空间中资源的清理释

2.7.补充点

可能有人会混着用malloc，new，delete和free，那这回发生什么呢？

例如：

假设在某个 VS2022 / MSVC 的具体实现下：

#include <iostream>

using namespace std;
class A
{
public:
	A(int a = 10)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};

int main()
{
	A* p1 = new A(1);
	free(p1);

	A* p2 = new A[10];
	free(p2);
	return 0;
}

输出结果：

要么会直接报错，要么就会直接卡在这里不懂。

解释：

A* p2 = new A[10];

而：

sizeof(A) == 4

10 个对象本身需要：

10 × 4 = 40 字节

实现可能还会额外保存一个"数组元素个数"，比如：

10

供 delete[] 将来知道要调用多少次析构函数。

可以把内存大致想成：

实际申请到的内存
↓
+------------+------+------+------+-----+
| 元素个数10 | A[0] | A[1] | A[2] | ... |
+------------+------+------+------+-----+
^            ^
真正分配地址   p2

所以**p2 返回给你的，并不一定是整块底层内存真正的起始地址** ，而是：指向第一个 A 对象的位置。

然后：

delete[] p2;

实现知道这是数组形式的释放，因此可能会先从 p2 往前找到保存的元素个数：

10

然后知道：哦，有 10 个 A 对象。

于是依次调用析构函数，一般是从后往前：

A[9]
A[8]
...
A[0]

最后再拿到真正的内存块起始地址，把整块内存释放。

而你如果：

free(p2);

那就完全不一样了。

free 看到的只是：

p2
 ↓
A[0]

它不知道前面还有 new[] 使用的管理信息，也不知道这里有 10 个 A 对象。

更关键的是，free 要求传入的地址必须是它认可的那块动态内存的起始地址 ，你现在给它的可能是块内部偏移后的地址。

所以可能直接导致：

invalid pointer
堆损坏
运行时崩溃
未定义行为

而且还有另一个问题：

free(p2);

不会调用那 10 个 A 的析构函数，也就会导致有些资源无法销毁。

所以你可以把整个区别理解成：

new A[10]

底层原始地址
    ↓
[数组管理信息][A0][A1][A2]...[A9]
              ↑
              p2

delete[] p2：

p2
↓
找到数组管理信息
↓
知道有10个对象
↓
调用10次析构函数
↓
找到真正的内存起始地址
↓
释放整块空间

注意 ：new[] 的实现通常需要某种方式保存数组元素数量等信息，以便 delete[] 正确析构和释放；具体保存几个字节、放在哪里，是编译器实现细节。

那如果我将析构函数给注释了呢？

输出结果：

解释：

这时 A 没有用户自定义析构函数，通常会变成一个"析构非常简单"的类型。

那么执行：

A* p2 = new A[10];

编译器就可能觉得：反正 delete[] 的时候根本不需要逐个调用什么特殊析构函数，那我也没必要额外记"这里有 10 个对象"。

所以在某些实现里，原来类似：

[数组元素个数][A0][A1]...[A9]
               ↑
               p2

可能直接变成：

[A0][A1][A2]...[A9]
 ↑
 p2

如果：

sizeof(A) == 4

那就可能只需要：

10 × 4 = 40 字节

而不是你前面看到的 44 字节。

警告：我们使用malloc，free和new，delete时要配套使用，不要混着中，或许现在使用看着结果是对的，但是以后就会发生意想不到的结果。

总结：

malloc/free 与 new/delete 都能管理堆空间，但 new/delete 对自定义类型还会自动调用构造函数和析构函数。new[]/delete[] 用于对象数组，编译器可能额外保存数组长度等管理信息，以便正确调用多次析构。

因此必须配套使用：

malloc ↔ free
new ↔ delete
new[] ↔ delete[]

即使某些情况下混用看起来"能运行"，本质上仍是不规范的，可能导致析构未执行、堆损坏或未定义行为。