【浅尝C++】C/C++内存管理（含程序地址空间验证代码、new/operator new/malloc/delete/operator delete/free的区别与联系）

🏠专栏介绍：浅尝C++专栏是用于记录C++语法基础、STL及内存剖析等。
🚩一些备注：之前的文章有点杂乱，这里将前面的知识点重新组织了，避免了过多冗余的废话。
🎯每日努力一点点，技术变化看得见。

---

C/C++内存分布

首先，我们来看一段关于C语言的程序。它演示了各类数据在内存中的存储位置。

#include <stdio.h>
#include <stdlib.h>

int ugval;
int gval = 1;
static int s = 0;

int main(int argc, char* argv[], char* env[])
{
	printf("代码段:%p\n", main);
	printf("初始化全局数据区:%p\n", &gval);
	printf("未初始化全局数据区:%p\n", &ugval);
	printf("静态区（数据段）:%p\n", &s);
	
	char* arr1 = (char*)malloc(sizeof(char) * 4);
	char* arr2 = (char*)malloc(sizeof(char) * 4);
	char* arr3 = (char*)malloc(sizeof(char) * 4);
	char* arr4 = (char*)malloc(sizeof(char) * 4);

	printf("堆区数据:%p\n", arr1);
	printf("堆区数据:%p\n", arr2);
	printf("堆区数据:%p\n", arr3);
	printf("堆区数据:%p\n", arr4);

	printf("栈区数据:%p\n", &arr1);
	printf("栈区数据:%p\n", &arr2);
	printf("栈区数据:%p\n", &arr3);
	printf("栈区数据:%p\n", &arr4);

	printf("命令行参数:%p\n", argv);
	printf("环境变量:%p\n", env);
	
	return 0;
}

由上面代码在Visual Studio下的执行结果分析出：堆是从高地址向高地址增长的，栈是从高地址向低地址增长的。命令行参数和环境变量存储位置相近。代码、全局变量、静态变量存储位置相近。

ps：这段代码只能证明某类参数的位置相近，无法说明它们存储位置的先后次序，因为不同的操作系统、编译器下的执行结果是不同的。下图是在Linux操作系统下，使用gcc编译后执行的结果。

下图根据Linux下gcc编译的执行结果总结了，程序中各类数据的存储位置。（代码段又称为常量区，数据段又称为静态区）↓↓↓

根据上面的执行结果，我们可以总结出如下结论：

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

( ఠൠఠ )ﾉtest：浏览下方程序，回答问题

int g_val = 1;
static int s_g_val = 1;
void test()
{
	static int s_val = 1;
	int loc = 1;
	
	int num[10] = {1,2,3};
	char arr[] = "jammingpro";
	const char* ps = "xiaoming";
	int* p1 = (int*)malloc(sizeof(int) * 2);
	int* p2 = (int)calloc(2, sizeof(int));
	int* p3 = (int)realloc(p2, sizeof(int) * 10);
	free(p1);
	free(p2);
	free(p3);
}

一、请问上述代码中的下列存储在哪个区域？

1. g_val_____ s_g_val______ s_val_____ loc_____ num_____
2. arr_____ *arr_____ ps______ *ps______ p1_____ *p1_____
   二、填写下列变量占据的字节数
3. sizeof(num)_____ sizeof(arr)_____ strlen(arr)_____
4. sizeof(ps)_____ strlen(ps)______ sizeof(p1)_____
   
   
   解答：
   1.g_val、s_g_val与s_val均放置在数据段（静态区），loc与num1位于栈区。
   2.arr、arr、ps、p1均放置在栈区，而ps位于代码段（常量区），*p1位于堆区
   3.sizeof(num)=40，sizeof(arr)=11，strlen(arr)=10
   4.sizeof(ps)=4或者8（在32位机器上为4，64位机器为8），strlen(ps)=8，sizeof(p1)=4或者8（在32位机器上为4，64位机器为8）
   上面问题答案如果有错误，或者疑问，欢迎在私信评论

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

C语言动态开辟内存有3种方式，即malloc、realloc与calloc。释放动态开辟的内存需要使用free方法。下面给出3种动态开辟空间方式的差别↓↓↓

1. malloc

功能：malloc函数用于动态分配指定大小的内存空间，并返回一个void类型的指针，指向分配的空间的首地址
参数：malloc函数只接受一个参数，即要分配的内存空间的大小（以字节为单位）
返回值：成功时返回分配的内存空间的首地址，失败时返回NULL
注意事项：malloc只分配内存，不会对内存进行初始化，所以得到的内存空间里面可能包含随机数据

2. realloc

功能：realloc函数用于重新分配之前已经分配的内存空间的大小，可以扩大或者缩小原有的内存空间
参数：realloc函数接收2个参数，第一个是之前动态分配的内存空间的指针，第二个是要重新分配的内存大小
返回值：成功时返回重新分配的内存空间首地址，失败时返回NULL
注意事项：在扩大内存空间时，realloc可能会将之前分配的内存空间内的数据拷贝到新的内存空间，并释放原有的内存空间。扩大内存的过程可能会涉及复制数据，效率较低

3. calloc

功能：calloc函数可以动态分配指定数量、指定大小的内存空间，并将分配的内存空间初始化为0
参数：calloc函数接收2个参数，第一个参数是要分配的内存块的数量，第二个参数是每个内存块的大小
返回值：成功时返回内存空间首地址，失败时返回NULL
注意事项：calloc会对分配的内存空间进行初始化，并将所有的内存位置置为0

C++内存管理方式

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

new/delete操作内置类型

下面给出new和delete的示例代码与使用方法示意图。

void test()
{
	//动态申请一个int类型的空间
	int* p1 = new int;
	//动态申请一个int类型的空间，并将其初始化为0
	int* p2 = new int(0);
	//动态申请10个int类型的空间
	int* p3 = new int[10];

	delete p1;
	delete p2;
	delete[] p3;
}

★ps：申请和释放单个元素空间时，使用new和delete运算符；申请和释放连续的空间，使用new[]和delete[]。

new和delete操作自定义类型

#include <iostream>
#include <cstdlib>
using namespace std;

class A
{
public:
	A()
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
};

void createInC()
{
	cout << "C语言申请和释放单个内置类型" << endl;
	A* p1 = (A*)malloc(sizeof(A));
	free(p1);
	cout << "========================================" << endl;
	cout << "C语言申请和释放多个内置类型" << endl;
	A* p2 = (A*)malloc(sizeof(A) * 5);
	free(p2);
	cout << "========================================" << endl;
}

void createInCPP()
{
	cout << "C++语言申请和释放单个内置类型" << endl;
	A* p1 = new A;
	delete p1;
	cout << "========================================" << endl;
	cout << "C++语言申请和释放多个内置类型" << endl;
	A* p2 = new A[5];
	delete p2;
	cout << "========================================" << endl;
}

int main()
{
	createInC();
	createInCPP();
	return 0;
}

由上面执行结果可以知道，在申请自定义类型的空间时，C语言的动态开辟和释放不会调用自定义类型的构造和析构函数；而C++种的new会调用构造函数，delete会调用析构函数。

new操作符自动调用构造函数的好处有什么？

我们可以在申请对象空间时，给对象成员初始化。↓↓↓

class Person
{
public:
	Person(string& name)
		:_name(name)
	{}
private:
	string _name;
};

void test()
{
	Person* p1 = new Person("jammingpro");
}

delete操作符自动调用析构函数的好处是什么？

对于某些类型的自定义类型，如栈，它在堆区开辟了空间，如果不使用析构函数释放该空间，将会导致内存泄漏。delete自动调用析构函数，可以防止程序员忘记释放申请的堆区空间。↓↓↓

class Stack
{
public:
	Stack(int n)
		:_arr(new int[n])
		,_size(0)
		,_capacity(n)
	{}
	~Stack()
	{
		delete[] _arr;
		_size = _capacity = 0;
	}
private:
	int* _arr;
	int _size;
	int _capacity;
};

void test()
{
	Stack* s = new Stack(5);
	delete s;
}

为什么new[]多个对象后，需要使用delete[]？

如果我们new[]了5个stack类型后，delete[]怎么知道需要调用5次析构函数呢？其实在new[]返回的首地址前存储了申请的内存块数，当使用delete[]后，会将指针挪动到该位置，再释放。（如下图所示）

operator new与operator delete

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

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

因而我们可以得出这6者的关系图↓↓↓

new和delete的实现原理

内置类型

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

自定义类型

●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来释
放空间

定位new（placement-new）

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

使用格式：

new (place_address) type

或者

new (place_address) type(initializer-list)

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

下面给出定位new的使用示例↓↓↓

class Person
{
public:
	Person(string& name)
		:_name(name)
	{}
private:
	string _name;
};

void test()
{
	Person* p1 = (Person*)malloc(sizeof(Person));
	new(p1)A("jammingpro");
	p1->~A();
	free(p1);

	Person* p2 = (Person*)operator new(sizeof(Person));
	new(p2)A("xiaoming");
	p2->~A();
	operator delete(p2);
}

★ps：为了避免不必要的错误，在开辟和释放空间时，各个运算符需要配套。new与delete配套、new[]与delete[]配套、operator new与operator delete配套、malloc与free配套。

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

内存泄漏

内存泄漏的含义及危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

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

下面给出内存泄漏的示例代码↓↓↓

void MemoryLeak()
{
	int* p1 = malloc(sizeof(int) * 100);
	//上面的空间忘记释放导致内存泄漏

	int* p2 = new int[50];
	ExcepFunc();//该函数内抛出异常，导致导致下面一行代码未知性而导致内存泄漏
	delete[] p2;	
}

内存泄漏的分类

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

堆内存泄漏
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生堆内存泄漏。

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

如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。

内存泄漏非常常见，解决方案分为两种：①事前预防型。如智能指针等。②事后查错型。如泄漏检测工具。（智能指针将在后序文章介绍）

🎈欢迎进入浅尝C++专栏，查看更多文章。
如果上述内容有任何问题，欢迎在下方留言区指正b(￣▽￣)d