【C++】动态内存管理以及模板

C++入门系列：
【C++】从C丝滑入门C++——初始C++
【C++】类和对象（一）
【C++】类和对象（二）
【C++】类和对象（三）

加粗样式>—

感兴趣的同学点击支持一下！

---

前言

在 c 语言中我们使用 malloc 和 free 进行堆空间的动态内存管理，C++ 中为了配合类的使用，引入了 new 和 delete 来进行对动态内存的管理。并且在 C++ 中引入了泛型的概念，引入了模板。本文笔者将带大家了解这两个知识点。

---

动态内存

C++ 的内存分布

在 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 在哪里？____
char2在哪里？____ *char2在哪里？___
pChar3在哪里？____ *pChar3在哪里？____
ptr1在哪里？____ *ptr1在哪里？____

---

C++ 中的动态内存开辟

在 C 中我们常用 malloc 、calloc 、free 等函数进行动态内存的开辟和释放。这些方法在 C++ 中仍然可以使用，但是在对一个类进行内存开辟时，我们使用这种方法后仍然需要对类进行初始化使用起来比较麻烦，因此 C++ 中又引入了新的动态内存开辟的方法：new 与 delete。

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

如果我们定义一个 int 数组对其初始化我们可以：

	int* ptr = new int[5]{1,2,3,4,5};

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

---

new 与 delete 的底层组成

在 C++ 中提供了一个全局的 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 new 和 operator delete 的代码实现可以发现其底层仍然是用 malloc 与 free 复用出的函数，不过其在此基础上添加了异常处理，在开辟失败时会抛出异常。

内置类型

如果申请的是内置类型的空间，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

我们写代码时可能会存在我们想先开辟一块空间，再对这片空间进行初始化。我们可以单独写一个初始化函数对其进行初始化，可是这样仍然增加了我们的工作量，因此 C++ 引入定位new的概念。我们可以使用下面的方法使用：

	new(指针)[自定义变量类型]
	new(指针)[自定义变量类型](初始化值)

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

---

模板

在 C++ 中我们有了函数的重载，可以实现了一个函数名不同参数的函数调用，可以实现了同一函数名的通用交换函数：

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}
void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
}
void Swap(char& left, char& right)
{
	char temp = left;
	left = right;
	right = temp;
}

---

我们虽然实现了一个通用的交换函数，但是我们需要手动的编写不同数据类型的函数重载。当我们每次出现一个新的数据类型时，我们都需要自己再添加一个函数，非常的麻烦。而模板则可以帮助我们解决这个问题。

---

函数模板

函数模板格式：在函数定义前添加

	template<typename T1,typename T2,...,typename Tn >	或
	template<class T1,class T2,...,class Tn >

注意：T1、T2… 可以看作变量名，使用者可以自行更改。

template<typename T>
void Swap( T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

这样我们在调用时，函数模板会自动转为我们需要的函数：

函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

隐式实例化：让编译器根据实参推演模板参数的实际类型：

在编译器编译阶段，函数调用的过程中，模板会自动化识别传入实参的数据类型，如果传入的是 int 类型则 T1 全部被替换为 int。然后专门生成一分 int 类型的代码。

显式实例化：在函数名后的<>中指定模板参数的实际类型

int main(void)
{
	int a = 10;
	double b = 20.0;
	// 显式实例化
	Add<int>(a, b);
	return 0;
}

类模板

类模板的定义格式

template<class T1, class T2, ..., class Tn>
class 类模板名
{
	// 类内成员定义
};

类模板只能显示的实例化：类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>
中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

其中在一个普通的类中，类的名字就是类的类型，而在类模板中类名不是类的类型，类名<实例化类型> 才是类型。