目录

• 一、C/C++内存分布
• 二、C++内存管理方式
• • 2.1 new/delete操作内置类型
  • 2.2 new和delete操作自定义类型
• 三、operator new与operator delete函数
• 四、new和delete的实现原理
• • 4.1 内置类型
  • 4.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.代码段(常量区)
globalVar在哪里？

• 全局变量，静态区

staticGlobalVar在哪里？

• 静态全局变量，静态区

staticVar在哪里？

• 静态局部变量，生命周期延长，静态区

localVar在哪里？

• 局部变量，出了函数作用域就销毁，栈区

num1在哪里？

• 在栈上开辟的数组num1，大小40字节，出栈销毁，数组名num1为指向第一个元素的指针，存放在 栈区

char2在哪里？

• "abcd"原是在常量区，后拷贝到栈区形成数组，char2指向栈上数组的第一个字符，存放在 栈区

*char2在哪里？

• 由上，解引用*char2得到拷贝到栈上的数组的第一个字符a， 栈区

pChar3在哪里？

• 字符串"abcd"在常量区，pChar3指向这个字符串(地址)，但pChar3本身为指针，存放在 栈区

*pChar3在哪里？

• 由上*pChar3，解引用后指向常量字符串，在 常量区

ptr1在哪里？

• 同理，malloc()在堆区上开辟了一段空间，ptr1指针指向这段动态开辟的堆区空间，指针本身还在 栈区

*ptr1在哪里？

• 由上，malloc()开辟空间在堆区，*ptr1解引用后拿到堆区上的数据，所以在 堆区

2. 填空题：
   sizeof(num1) = 40; // sizeof(int)* 10 — sizeof(数组名)，此时为整个数组大小
   sizeof(char2) = 5; // 还有一个'\0'
   strlen(char2) = 4; // 到'\0'结束，此时char2为字符数组的第一个元素的地址
   sizeof(pChar3) = 4 or 8; // 指针大小固定为 4 or 8 区别在于机器位数
   strlen(pChar3) = 4;
   sizeof(ptr1) = 4 or 8;
   如还需进一步了解，还可参考 详解sizeof()和strlen()的细节及用法 一文。sizeof是一个运算符，在编译时根据类型大小定义，自定义类型根据内存对齐规则计算大小(编译时就是一个具体的值！)；而strlen是一个函数，运行时计算字符长度，事实上在编译时就没有此函数了，被转换为了一个个指令(即call此函数实现地址，执行内部指令`)！

【说明】

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

C语言中动态内存管理方式：malloc/calloc/realloc/free

【面试题】: malloc/calloc/realloc的区别？ 参考 【c语言】详解动态内存管理 一文。

二、C++内存管理方式

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

2.1 new/delete操作内置类型

1. 用法上，变简洁了

int* p0 = (int*)malloc(sizeof(int)); int* p1 = new int; int* p2 = new int[10]; // new 10 个int 对象  delete p1; delete[] p2; 

2. 可以控制初始化

int* p3 = new int(10); //动态申请一个int类型的空间 int* p4 = new int[10] {1, 2, 3, 4, 5};  //动态申请十个int类型的空间并初始化为{...}， 其余为0 

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

2.2 new和delete操作自定义类型

3. new/delete对于自定义类型除了开空间还会调用构造函数和析构函数，内置类型是几乎是一样的

class A { public: 	A(int a = 0) 		: _a(a) 	{ 		std::cout << "A():" << this << std::endl; 	} 	~A() 	{ 		std::cout << "~A():" << this << std::endl; 	} private: 	int _a; }; int main() { 	// new/delete 和 malloc/free最大区别是  	// new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数 	A* p1 = (A*)malloc(sizeof(A)); 	A* p2 = new A(1); 	free(p1); 	delete p2; 	return 0; } 

调用new动态开辟内存，编译器会自动帮我们计算要开辟的空间，并调用operator new全局函数(其是对malloc的封装，失败抛异常也是在这一层，为了实现new)，然后再调用自定义类型的构造函数。从汇编角度，如下：

new [n]是会调用operator new[]函数(其是对operator new的封装) 和 n 次构造函数。

delete释放空间也相似，只不过先调用析构函数，再释放空间。 至于为什么，参考如下情况：

class MyStack { public: 	MyStack() 		: _a((int*)malloc(sizeof(int) * 4)) 		,_capacity(4) 		, _top(0) 	{}  	~MyStack() 	{ 		free(_a); 		_top = _capacity = 0; 	} private: 	int* _a; 	int _capacity; 	int _top; };  int main() { 	MyStack* st = new MyStack; 	delete st; 	return 0; } 

若先调用operator delete，_a指针变量所在的地址空间将被释放，无法找到malloc开辟的堆上空间！

再来观察如下现象，new A开辟的是4字节空间，但是new A[10]开辟的却是44字节空间，这是为什么呢？

new A调用一次operator new和一次构造函数；同理new A[10]调用十次operator new和十次构造函数，因为[]中传有开辟对象个数。那么delete调用一次析构和一次operator delete，但是delete[]可就不一样了，因为[]中没有传析构次数，所以编译器就不知道。那么为了让编译器知道次数，就在开辟的空间顶上多开辟4个字节来存放对象个数(X86环境，实测X64环境下多开辟8字节)，只有这样delete[]才知道调用多少次析构函数。

当然也有很多情况不会在顶上多开辟空间：1. new内置类型，不需要析构；2. 没有显示写析构函数的自定义类型。（基于编译器的优化）

new和delete不匹配问题：

一个非常典型的问题（基于编译器的优化）就是：当new多个自定类型时(A* p = new A[10])，且直接使用delete A，如果A类显示实现析构函数就会报错，如果不写析构函数就不会报错！ 这与上面那个问题密切相关，即是否多开辟空间存对象个数。

如果显示实现了析构函数，p3并没有指向动态开辟内存的起始位置，且delete又不知道要向前偏移，所以直接释放了动态开辟的内存的中间位置，导致报错！ 而不实现析构函数，就不会多开辟空间，也就避免了这样的问题。当然两者情况都可能会导致内存泄漏的问题！：

所以new和delete一定要匹配使用，因为导致的结果可能是不确定的！

4. new失败了以后抛异常，不需要手动检查，捕获异常方式：

try { 	func(); // 其中调用new } catch(const std::exception& e) { 	std::cout << e.what() << std::endl; } 

运用如上这些定理我们自己实现单链表也变得方便的多了！首先我们可以先创建一个类来描述单链表，然后单独实现创建链表的函数。

可以先创建一个哨兵位(MyList head(-1);，栈上开辟，此节点为了方便后续链表节点的链接，且在创建单链表函数结束时自动销毁)；然后通过cin输入链表节点值(val)，并在堆上开辟链表节点(new MyList(val);，此时还会调用MyList类的构造函数)；最后再链接各节点，并返回哨兵位后一个节点(head._next)，即链表初始节点(哨兵位节点，栈上空间，出作用域自动销毁)。

//C++中List单链表的创建 struct MyList { 	MyList(int val = 0) 		:_next(nullptr) 		,_val(val) 	{}  	MyList* _next; 	int _val; };  MyList* CreatList(int n) { 	MyList head(-1);//哨兵位  ---  出栈销毁  	MyList* tail = &head; 	int val; 	std::cout << "请以此输入" << n << "个节点的值:> " << std::endl; 	for (size_t i = 0; i < n; i++) 	{ 		std::cin >> val; 		tail->_next = new MyList(val);  // 堆上开辟，链表实体; 且自动调用构造函数 		tail = tail->_next; 	} 	//返回哨兵位后面一个节点 	return head._next; } int main() { 	MyListNode* head = CreatListNode(1); 	return 0; } 

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

三、operator new与operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new和operator delete是系统提供的全局函数(不是重载！)，new在底层调用operator new 全局函数来申请空间（对malloc的封装），delete在底层通过operator delete全局函数来释放空间（对free的封装）。

/* 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来释放空间的。

四、new和delete的实现原理

4.1 内置类型

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

4.2 自定义类型

new的原理

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

delete的原理

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

new T[N]的原理

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

delete[]的原理

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