四、C++内存管理

1 C/C++内存分布

在学习C++的内存管理方式之前，我们先来看一道有关C/C++内存分布的题目：

阅读下面的代码，回答相关问题：
#include <iostream>
using namespace std;
int globalVar = 1;
static int staticGlobalVar = 1;
int main()
{
	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);
	return 0;
}

//1. 选择题：
//   选项: A.栈  B.堆  C.数据段(静态区)  D.代码段(常量区)
//   globalVar在哪里？____   staticGlobalVar在哪里？____
//   staticVar在哪里？____   localVar在哪里？____
//   num1 在哪里？____
//   char2在哪里？____       *char2在哪里？___
//   pChar3在哪里？____      *pChar3在哪里？____
//   ptr1在哪里？____        *ptr1在哪里？____

//2. 填空题：
//   sizeof(num1) = ____ ;
//   sizeof(char2) = ____;      strlen(char2) = ____;
//   sizeof(pChar3) = ____;     strlen(pChar3) = ____;
//   sizeof(ptr1) = ____;

图解：

从图解中可以知道，C++的内存分布和C语言是一脉相承的，那么在动态内存上C++和C语言有没有不同呢？

2 C++动态内存管理

2.1 new和delete

在C语言阶段，我们使用malloc、calloc、realloc和free进行动态内存管理，而在C++中，还引入了new和delete进行动态内存管理，其语法为：

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

例：

int* p1 = new int;//申请1个int，不初始化
int* p2 = new int(10);//申请1个int，初始化为10
int* p3 = new int[10];//申请1个有10个int的数组，不初始化
int* p4 = new	int[10]{ 1,2,3,4 };申请1个有10个int的数组，前4个元素初始化为1、2、3、4

delete p1;
delete p2;
delete[] p3;
delete[] p4;

可以看到，和malloc相比，new可以在开辟空间的同时对其初始化。

和free相比，使用delete进行释放时，需要注意以下两个情况：

情况一：

#include <iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	A* p9 = new A[10];
	delete p9;
	//free(p9);
	//delete[] p9;
	return 0;
}

使用delete和free的运行结果：

使用delete[]的运行结果：

从运行结果可以看到，当我们使用delete和free进行释放时，程序被终止运行了，这是为什么呢？

实际上，我们在使用new来开辟一块连续的空间时，当编译器发现A这个类中显式设置了析构函数时，它会在刚开辟空间的前面再多开一点空间来存放开辟的个数，当用delete释放空间时，该个数可以帮助编译器判断需要调用多少次析构函数。

但问题就出在，当开辟这块用来存放个数的空间后，new返回的并不是这一整块空间的起始地址，而是真正用来存放数据的空间的地址，就像下面这样：

而又由于调用delete释放空间时，它是从当前指针指向的位置开始释放的，所以在指针位置不对的情况下，运行到后边自然就会出错了。

与delete不同的是，delete[]会先将指针返回这一整块空间的起始地址，而后再进行释放，所以调用delete[]进行释放的时候可以正常运行。

情况二：

#include <iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	/*~A()
	{
		cout << "~A():" << this << endl;
	}*/
private:
	int _a;
};
int main()
{
	A* p9 = new A[10];
	//delete p9;
	//free(p9);
	delete[] p9;
	return 0;
}

使用delete、free和delete[]的运行结果：

从输出结果可以看到，当我们把刚才那段代码中的析构函数屏蔽后，程序也能够正常运行。原因就在于使用new开辟空间时，编译器没有在A这个类中发现显式设置的析构函数，根据之前的学习我们知道，此时它会调用默认的析构函数，而编译器聪明的地方就在于它评估一下之后发现这里不调用析构函数也可以，既然不调用析构函数，也就自然不需要另开辟一块空间来记录析构函数的次数了，因此在这里使用delete、free和delete[]三个函数进行释放都不会出错。

实际上，关于这一特性，并不是所有的编译器都会这样，具体情况还是要取决于自己使用的编译器。

虽然通过刚才的情况我们发现好像new和delete不匹配使用也没有问题，但这里需要强调的是：new和delete一定要匹配起来使用，不要使用new开辟空间后用free释放，亦或者是使用malloc开辟空间后用delete释放，否则会出现难以预料的情况，关于原因等后续再进行解释。

2.1 new、delete和malloc、free的区别

实际上，对于内置类型，new、delete和malloc、free的作用几乎是一样的。

不同的地方是：new在申请空间失败时会抛异常，而malloc则会返回NULL。

例：

#include <iostream>
using namespace std;
int main()
{
	int* p1 = (int*)malloc(sizeof(int)); 
	int* p2 = new int;
	*p1 = 1;
	*p2 = 1;
	cout << "p1:" << *p1 << endl;
	cout << "p2:" << *p2 << endl;
	free(p1);
	delete p2;
}

运行结果：

真正的区别在于，new和delete对于自定义类型，除了会为其开辟空间还会调用它的构造函数和析构函数，而malloc和free则无法实现。

例：

#include <iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	cout << "----------" << endl;
	A* p1 = (A*)malloc(sizeof(A));
	cout << "----------" << endl;
	A* p2 = new A(1);
	cout << "----------" << endl;
	free(p1);
	cout << "----------" << endl;
	delete p2;
	cout << "----------" << endl;
	A* p3 = (A*)malloc(sizeof(A) * 10);
	cout << "----------" << endl;
	A* p4 = new A[10];
	cout << "----------" << endl;
	free(p3);
	cout << "----------" << endl;
	delete[] p4;
	return 0;
}

运行结果：

为了方便观察，我们特地用cout将使用malloc和free的地方隔开，以观察它们在执行时有没有进行其他操作。

从输出结果可以看到，当用malloc和free开辟和释放空间时，它们没有进行别的操作，而用new和delete释放空间时，它们还会调用A类的构造函数和析构函数。

总结：malloc、free和new、delete的区别

1. malloc和free是函数，new和delete是操作符。
2. malloc申请的空间不会初始化，new可以初始化。
3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，在[]中指定对象个数即可。
4. malloc的返回值为void*, 在使用时必须强转，new不需要。
5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new申请失败时则抛异常。
6. 申请自定义类型对象时，malloc、free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理。

2.2 new和delete的底层原理

实际上，C++还在系统中提供了operator new和operator delete两个全局函数，new就是通过在底层调用operator new全局函数来申请空间，delete则是通过在底层调用operator delete全局函数来释放空间。

特别注意：operator new和operator delete是两个函数，不是对new和delete的重载！

下面展示了operator new和operator delete在库中的源代码：

//operator new
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
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和delete通过在底层调用operator new和operator delete来申请和释放空间，但是从源代码中我们可以注意到的是，operator new函数实际上是通过malloc来申请空间的，而operator delete函数实际上也是通过free来释放的。

实际上，operator new和operator delete是对malloc和free的封装。对于operator new而言，是将malloc和调用构造函数封装在了一起；而对于operator delete而言，除了将free和调用析构函数封装在一起，还多了一些检查。

总结：

1. new的原理
   1. 调用operator new函数申请空间。
   2. 在申请的空间上执行构造函数，完成对象的构造。
2. delete的原理
   1. 在空间上执行析构函数，完成对象中资源的清理工作。
   2. 调用operator delete函数释放对象的空间。
3. new T [N]的原理
   1. 调用operator new[]函数申请空间，实际上是在operator new[]中实际调用operator new函数完成N个对象空间的申请。
   2. 在申请的空间上执行N次构造函数，完成对象的构造。
4. delete[]的原理
   1. 在释放对象的空间上执行N次析构函数，完成N个对象中资源的清理。
   2. 调用operator delete[]函数释放空间，实际上是在operator delete[]中调用operator delete来释放空间。

2.3 new和delete需匹配使用的原因

知道了new、delete和malloc、free的区别，以及new、delete的底层原理，就可以解答new和delete一定要匹配起来使用的原因了。

刚才我们说new和delete如果不匹配起来使用的话，就可能会出现难以预料的情况，之所以说是难以预料，是因为它并不是只要混用就会出错。

情况一：

//会报错吗？
int* p1 = new int[10];
free(p1);

这种情况下，由于是对int这个内置类型开辟空间，并不涉及构造和析构的问题，所以不用delete影响不大，即不会报错。

情况二：

//会报错吗？
#include <iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	A* p8 = new A;
	free(p8);
	return 0;
}

运行结果：

和情况一相比，情况二用new为A类开辟了空间，可为什么用free释放程序还是能正常运行呢？

实际上，这是因为这里只是没有调用析构函数，而只有当析构函数里涉及资源释放的时候，不用delete释放才有问题。而正好这个例子中的析构函数并没有涉及到资源释放，所以程序能够正常运行。

情况三：

#include <iostream>
using namespace std;
class Stack
{
public:
	Stack()
	{
		cout << "Stack()" << endl;
		_a = new int[4];
		_top = 0;
		_capacity = 4;
	}
	~Stack()
	{
		cout << "~Stack():" << this << endl;
		delete[] _a;
		_top = _capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack* pst = new Stack;
	free(pst);
	return 0;
}

运行结果：

从输出结果可以看到，使用free释放空间后还是没有调用析构函数。刚才我们说只有当析构函数里涉及资源释放的时候，不用delete释放才有问题，可情况三的析构函数~Stack明明涉及到资源释放了，为什么使用free来释放空间后，程序还是能够正常运行呢？

图解：

从图解可以知道，情况三出现内存泄漏的问题是无疑的，但是问题就在于编译器并不能帮我们检查出来，也就是说只有当泄漏的空间大到导致程序崩溃之后才会发现，而这种情况如果发生在今后工作中的话后果是不可想象的，所以new和delete一定要匹配起来使用。

2.4 定位new表达式

如果我们想在一块已分配内存空间中调用构造函数来初始化一个对象，这个时候用new就不行了，取而代之的是定位new。

其语法为：

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

说明：

1. place_address必须是一个指针。
2. initializer-list是类型的初始化列表 。

例：

#include <iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
// 定位new/replacement new
int main()
{
	//p1现在指向的只是与一个A对象相同大小的空间，由于还没有执行构造函数，因此还不能算一个对象。
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A;// 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();
	free(p1);
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}

运行结果：

在现阶段，定位new的意义好像并不大，实际上，定位new表达式一般是配合内存池使用，因为内存池分配出的内存并没有初始化，所以如果是自定义类型的对象，需要使用new的定位表达式来显式调用构造函数完成初始化。

关于内存池的更多特性，在后续会进行详细地介绍。