前言

我们知道在 C 语言中，可以使用 malloc、realloc、calloc 来开辟空间，使用 free 来销毁空间。

那么在 C++ 中，我们该如何向内存申请空间呢？

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

1、选择题：

答案：

globalVar 存储于 数据段
 
staticGlobalVar 存储于 数据段
 
staticVar 存储于 数据段
 
localVar 存储于 栈
 
localVar1 存储于 栈
 
num1 存储于 栈
 
char2 存储于 栈（因为 char2 是一个数组，存在栈上面的，而 “abcd” 是存在常量区的常量，只是拷贝给了 char2）
 
*char2 存储于 栈（数组名就是首元素的地址，也就是 char 是地址，*char2 相当于对 cahr2 进行解引用，找到它的内容，那么它的内容是存储在栈上面的）
 
pChar3 存储于 栈（pChar3 是一个指针变量，这个指针变量是在栈上面开的）
 
*pChar3 存储于 代码段（pChar3 是一个指针变量，它存的是一个地址，它指向常量区的字符串 “a b c d”，*pChar 就是对这个指针变量解引用，找到了它的内容，也就是 “abcd” ，所以它是存在代码段的）
 
ptr1 存储于 栈
 
*ptr1 存储于 堆

2、填空题：

答案：

注意：sizeof 是求字节大小，strlen 是求字符串长度的。
 
sizeof(num1) = 40（算对象占用空间的大小）
 
sizeof(char2) = 5（char2 是一个字符数组，求大小要计算 ‘\0’）
 
sizeof(pChar3) = 4/8 （指针在 32 位平台大小是 4，64 位平台大小是 8）
 
sizeof(ptr1) = 4/8
 
strlen(char2) = 4（char2 是一个字符数组，求长度不计算 \0）
 
strlen(pChar3) = 4

我们再来看一张 C/C++中程序内存区域划分 的图：

名词解释：

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

注意：为什么说栈是向下增长的，而堆是向上增长的？

因为，一般情况下，在栈区开辟空间，先开辟的空间地址较高，而在堆区开辟空间，先开辟的空间地址较低。

例如，下面代码中，变量 a 和变量 b 存储在栈区，指针 c 和指针 d 指向堆区的内存空间：

#include <iostream>
using namespace std;

int main()
{
	//栈区开辟空间，先开辟的空间地址高
	int a = 10;
	int b = 20;
	cout << &a << endl;
	cout << &b << endl;

	//堆区开辟空间，先开辟的空间地址低
	int* c = (int*)malloc(sizeof(int) * 10);
	int* d = (int*)malloc(sizeof(int) * 10);
	cout << c << endl;
	cout << d << endl;
	return 0;
}

我们可以运行上面的代码，可以看出，a 和 b 的地址是大于 c 和 d 的地址

因为在栈区开辟空间，先开辟的空间地址较高，所以打印出来 a 的地址大于 b 的地址；

在堆区开辟空间，先开辟的空间地址较低，所以 c 指向的空间地址小于 d 指向的空间地址。

注意：

在堆区开辟空间，后开辟的空间地址不一定比先开辟的空间地址高。
 
因为在堆区，后开辟的空间也有可能位于前面某一被释放的空间位置。

2. C语言内存管理方式

（1）malloc

malloc 函数的功能是开辟指定字节大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个 NULL（空指针）。

它使用的时候，传参只需传入需要开辟的字节个数。

（2）calloc

calloc 函数的功能也是开辟指定大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个 NULL（空指针）。

calloc 函数传参时需要传入开辟的内存用于存放的元素个数和每个元素的大小。

calloc 函数开辟好内存后会将空间内容中的每一个字节都初始化为 0。

（3）realloc

realloc 函数可以调整已经开辟好的动态内存的大小，第一个参数是需要调整大小的动态内存的首地址，第二个参数是动态内存调整后的新大小。

realloc 函数与上面两个函数一样，如果开辟成功便返回开辟好的内存的首地址，开辟失败则返回 NULL（空指针）。

注意：realloc 函数调整动态内存大小的时候会有三种情况：

• 原地扩。需扩展的空间后方有足够的空间可供扩展，此时，realloc 函数直接在原空间后方进行扩展，并返回该内存空间首地址（即原来的首地址）。
• 异地扩。需扩展的空间后方没有足够的空间可供扩展，此时，realloc 函数会在堆区中重新找一块满足要求的内存空间，把原空间内的数据拷贝到新空间中，并主动将原空间内存释放（即还给操作系统），返回新内存空间的首地址。
• 扩容失败。需扩展的空间后方没有足够的空间可供扩展，并且堆区中也没有符合需要开辟的内存大小的空间。结果就是开辟内存失败，返回一个 NULL（空指针）。

（4）free

free 函数的作用就是将 malloc、calloc 以及 realloc 函数申请的动态内存空间释放，其释放空间的大小取决于之前申请的内存空间的大小。

关于 malloc、calloc、realloc 和 free 的具体用法，请参考：

3. C++内存管理方式

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

🍑 new和delete操作内置类型

（1）new 一个 int 类型的对象

int main()
{
	// 动态申请一个int类型的空间
	int* p1 = new int;

	// 销毁p1
	delete p1;

	return 0;
}

等价于用 malloc 来定义：

int main()
{
	// 用malloc动态申请一个int类型的空间
	int* p1 = (int*)malloc(sizeof(int));

	// 销毁p1
	free(p1);

	return 0;
}

（2）new 10 个 int 类型的对象

int main()
{
	// 动态申请10个int类型的空间
	int* p2 = new int[10];

	// 销毁p1
	delete[] p2;

	return 0;
}

等价于用 malloc 来定义：

int main()
{
	// 动态申请10个int类型的空间
	int* p2 = (int*)malloc(sizeof(int) * 10);

	// 销毁p2
	free(p2);

	return 0;
}

（3）new 一个 int 类型对象，然后初始化为 10

int main()
{
	// 动态申请一个int类型的空间并初始化为10
	int* p3 = new int(10);

	// 销毁p3
	delete p3;

	return 0;
}

等价于用 malloc 来定义：

int main()
{
	int* p3 = (int*)malloc(sizeof(int));
	*p3 = 10; //赋值

	//销毁p3
	free(p3);

	return 0;
}

（4）new 10 个 int 类型对象，并进行初始化

int main()
{
	//动态申请10个int类型的空间并初始化为1到10
	int* p4 = new int[10]{ 1,2,3,4,5,6,7,8,9,10 };

	//销毁p4
	delete[] p4;
	
	return 0;
}

如果我们只初始化第一个对象的话，后面 9 个对象默认为初始化为 0

等价于用 malloc 来定义：

int main()
{
	//动态申请10个int类型的空间并初始化为1到10
	int* p8 = (int*)malloc(sizeof(int) * 10); //申请

	for (int i = 0; i < 10; i++) //赋值
	{
		p8[i] = i;
	}

	free(p8); //销毁

	return 0;
}

我们再来看一张详细图：

注意：

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

🍑 new和delete操作自定义类型

对于内置类型而言，用 malloc 和 new 除了用法不同，其他没什么区别，但是，它们的区别在于 自定义类型！

对于下面这段代码相信大家很熟悉吧，是我们前面学过的链表定义节点的方法：

//链表
struct ListNode
{
    ListNode* next;
    int val;
};

//申请节点
struct ListNode* BuyListNode(int x) {
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    assert(node);

    node->next = NULL;
    node->val = x;
    return node;
}

int main()
{
    // 定义n1节点
    struct ListNode* n1 = BuyListNode(1);

    return 0;
}

有没有发现，如果用 C 语言的这套方式来定义的话，是不是很繁琐？

那么我们可以用 new 来改进一下：

//链表
struct ListNode
{
    ListNode* _next;
    int _val;

    //构造函数
    ListNode(int val = 0)
        :_next(nullptr) // 初始化列表
        , _val(val)
    {}
};

int main()
{
    // 定义n1节点
    ListNode* n2 = new ListNode(2); // new会去调用ListNode的构造函数

    return 0;
}

这样是不是很方便？

所以 C++ 的 new，相当于我们之前写的 BuyListNode 函数，也就是说，针对自定义类型，malloc 只能开空间，但是 new 是 开空间 + 调用构造函数进行初始化

🍑 总结

（1）C++ 中如果是申请内置类型的对象或是数组，用 new/delete 和 malloc/free 没有什么区别。

（2）如果是自定义类型的话，new 和 delete 分别是 开空间+构造函数、析构函数+释放空间，而 malloc 和 free 仅仅是 开空间和释放空间，可以看到区别还是很大的。

（3）建议在 C++ 中无论是内置类型还是自定义类型的申请和释放，尽量都使用 new 和 delete。

4. operator new 与 operator delete

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

operator new 和 operator delete 是系统提供的全局函数，new 在底层调用 operator new 全局函数来申请空间，delete 在底层通过operator delete 全局函数来释放空间。

operator new 和 operator delete 的用法与 malloc 和 free 的用法完全一样，其功能都是在堆上申请和释放空间。

下面是 operator new 和 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;
}

new 先去调用 operator new，然后，operator new 的底层是通过调用 malloc 函数来申请空间的，当 malloc 申请空间成功时直接返回；若申请空间失败，则尝试执行空间不足的应对措施，如果该应对措施用户设置了，则继续申请，否则抛异常。

而 operator delete 的底层是通过调用 free 函数来释放空间的。

🍑 类专属重载

那么 operator new 和 operator delete 什么时候用呢？

假设有下面这样一个链表，我们现在对链表进行插入数据

struct ListNode
{
	ListNode* _next;
	ListNode* _prev;
	int _data;

	// 构造函数
	ListNode(int data = 0)
		:_next(nullptr)
		,_prev(nullptr)
		,_data(data)
	{
		cout << "ListNode()" << endl;
	}
};

class List
{
public:
	List()
	{
		_head = new ListNode; // 调用 operator new + 构造函数
		_head->_next = _head;
		_head->_prev = _head;
	}

	//尾插
	void PushBack(int val) 
	{
		ListNode* newnode = new ListNode;
		ListNode* tail = _head->_prev;

		// _head(头)     _tail(尾)       newnode(新节点)
		tail->_next = newnode;
		newnode->_prev = tail;
		newnode->_next = _head;
		_head->_prev = newnode;
 	}

	//析构函数
	~List()
	{
		ListNode* cur = _head->_next;
		while (cur != _head)
		{
			ListNode* next = cur->_next;
			delete cur;
			cur = next;
		}
		delete _head;
		_head = nullptr;
	}
private:
	ListNode* _head;
};

int main()
{
	List l;
	int n;
	cin >> n;
	for (int i = 0; i < n; ++i) { // 向链表里面插入n个数据
		l.PushBack(i);
	}
	return 0;
}

如果我们输入 1000，那么就会向堆申请 1000 次空间。

也就是说会去：调用 new，然后又调用 operator new，最后再调用 malloc。

也就是说，现在这 1000 个数据是存在链表里面的，那么我把这堆数据用完，就会去把它清理掉，但是过了一会儿，我又要开辟空间去存放另外一对数据…

可以发现，在这个过程中，堆 会反复的给我们 申请空间，然后又 释放空间。

（其实有点像购物车的机制，把某个商品添加到购物车，然后又把某个商品从购物车删除）

那么有没有什么好的方法可以不向堆去申请空间呢？当然有！

这个时候就会引出一个新的概念：池化技术。

我可以自己建一个 内存池，我要 申请 和 释放 空间就去找我创建的内存池，那么它和堆的区别在哪里呢？内存池离你更近，它更快，可以提高效率

这时，C++ 提出了一种机制：类专属重载，不破坏原有方式，我还是会去调用 new，但是我们可以把 operator new 进行修改，因为 operator new 在没有动它的情况下，它默认是调用全局的 operator new，也就是说，它会去找 堆，然后进行申请和释放空间。

针对上面的代码，我们可以在 ListNode 里面去写一个 operator new 和 operator delete 函数，这里面就可以走一个 内存池 的机制。

struct ListNode
{
	ListNode* _next;
	ListNode* _prev;
	int _data;

	// 构造函数
	ListNode(int data = 0)
		:_next(nullptr)
		,_prev(nullptr)
		,_data(data)
	{
		cout << "ListNode()" << endl;
	}
	
	//专属operator new
	void* operator new(size_t n)
	{
		void* p = nullptr;
		p = allocator<ListNode>().allocate(1);
		cout << "memory pool allocate" << endl;
		return p;
	}
	
	//专属operator delete
	void operator delete(void* p)
	{
		allocator<ListNode>().deallocate((ListNode*)p, 1);
		cout << "memory pool deallocate" << endl;
	}
};

这个时候申请空间就不会向系统申请了，而是走我们自己写的专属的 operator new。

我们再输入 100，那么就会向 内存池 申请 100 次内存；

5. new和delete的实现原理

🍑 内置类型

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

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

🍑 自定义类型

（1）new 的原理

• 调用 operator new 函数申请空间。

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

（2）delete 的原理

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

• 调用 operator delete 函数释放对象的空间。

（3）new T[N] 的原理

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

• 在申请的空间上执行 N 次构造函数。

（4）delete[ ] 的原理

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

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

6. 定位 new 表达式

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

使用格式： new(place_address) type 或者 new(place_address) type(initializer-list)。

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

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

代码示例

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

private:
	int _data;
};

void Test()
{
	// pt现在指向的只不过是与Test对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	Test* pt = (Test*)malloc(sizeof(Test));

	new(pt) Test; // 注意：如果Test类的构造函数有参数时，此处需要传参
}

注意： 在未使用定位 new 表达式进行显示调用构造函数进行初始化之前，malloc 申请的空间还不能算是一个对象，它只不过是与 Test 对象大小相同的一块空间，因为构造函数还没有执行。

7. 常见面试题

🍑 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 在释放空间前会调用析构函数完成空间中资源的清理。

🍑 内存泄漏

什么是内存泄漏？内存泄漏的危害是什么？

内存泄漏：是指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。

内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

可以通过下面这段代码来理解：

void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;

	// 2.异常安全问题
	int* p3 = new int[10];

	Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放

	delete[] p3;
}

🍑 内存泄漏分类

C/C++ 程序中一般我们关心两种方面的内存泄漏：

（1）堆内存泄漏(Heap leak)

堆内存指的是程序执行中依据须要分配通过 malloc / calloc / realloc / new 等从堆中分配的一块内存，用完后必须通过调用相应的 free 或者 delete 删掉。

假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生 Heap Leak。

（2）系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

🍑 如何避免内存泄漏

（1）工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。

ps：这个是理想状态，但是如果碰上异常时，就算注意释放了，还是可能会出问题。可能需要智能指针来管理才有保证。

（2）采用 RAII 思想或者智能指针来管理资源。

（3）有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。

（4）出问题了使用内存泄漏工具检测。（ps：不过很多工具都不够靠谱，或者收费昂贵）。

🍑 总结

总结一下，内存泄漏非常常见，解决方案分为两种：

（1）事前预防型。如智能指针等。

（2）事后查错型。如泄漏检测工具。

🍑 如何一次在堆上申请 4G 的内存？

在堆上申请 4G 的内存：

#include <iostream>
using namespace std;

int main()
{
	try
	{
		//char* p = new char[0x7fffffff];//2G
		char* p = new char[0xffffffff];//4G
		printf("%p\n", p);
	}
	catch (const exception& e)
	{
		cout << "内存申请失败" << endl;
	}
	return 0;
}

如果我们运行这段代码，发现会报错：

因为，在 32 位的平台下，内存大小为 4G，但是堆只占了其中的 2G 左右，所以我们不可能在 32 位的平台下，一次性在堆上申请 4G 的内存。

这时我们可以将编译器上的 x86 改为 x64，即 64 位平台，这样我们便可以一次性在堆上申请 4G 的内存了。

然后我们在运行这段代码，就可以看到申请成功了。