初阶C++—— 第三节—— 动态内存管理 初识模板

我们还是先回到上一章节所说的段子：

编程世界，一切皆对象。如果没有对象的话，那就new一个出来。

这里的new就是和动态内存管理有关系了。我们今天来好好地说一说。

首先，还记得我们之前所说的C/C++的内存分布吗？

这个图其实我们已经引用第二次了。

预备知识

我们认为，C/C++ 包含内核空间、栈区、内存映射段、堆区、数据段、代码段等。

该图引自0基础C语言自学保姆教程——第十一节 自定义类型（结构体、枚举、位段、联合）与预处理指令（#define、#include等）_jxwd的博客-CSDN博客

由于我们之前已经详细地说过，我们在这里就不再赘述。

同样，malloc/ralloc/calloc的联系和区别我们在这里也不再赘述，因为同样的道理，我们之前已经详细地探讨过了。

我们今天主要来讨论两个关键字：

new 和 delete。

C++内存管理方式

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力而且使用起来比较麻烦。

因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理

基本操作

开辟释放内置类型：

我们来举一个例子：

void func()
{
    int* ptr1 = new int;
    int* ptr2 = new int(10);  //动态申请一个，并初始化为10
    int* ptr3 = new int[3];   //动态申请三个int的空间

    delete ptr1;
    delete ptr2;
    delete[]ptr3;
}

如上所示，

需要注意的是：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]

开辟释放自定义类型

与malloc和free不同的是，new和delete在开辟和释放空间的时候，会调用构造和析构函数。

我们来举一个例子：

class Test
{
public:
    Test()
        : _data(0)
    {
        cout << "Test():" << this << endl;
    }
    ~Test()
    {
        cout << "~Test():" << this << endl;
    }
private:
    int _data;
};
void Test2()
{
    // 申请单个Test类型的空间
    Test* p1 = (Test*)malloc(sizeof(Test));
    free(p1);

   /* Test* p3 = new Test;
    delete p3;*/
}
int main()
{
    Test2();
    return 0;
}

operator new与operator delete函数

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

通过转到定义，我们能看出其底层调用的是operator new函数。

而实际上：

operator new 实际也是通过malloc来申请空间，

如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。

而operator delete 最终是通过free来释放空间的。

说了那么多，我们来总结一下：

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

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

初识模板

有些函数，如果仅仅是类型不同，代码的重复率较高，虽然用函数重载也可以实现，但是极为麻烦，维护效率也比较低。

那么我们有没有一种方法来解决上述的问题呢？

答案就是用函数模板。

说白了，就是告诉编译器一个模子，让其自己根据类型模子来去生成代码。

我们在这里，提到一个概念：泛型编程。

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

函数模板

概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本

函数模板格式

template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}

举个例子：

就像这样。

注意，这里的class可以换成typename。但是不可以用struct。

函数模板的原理

函数模板是一个蓝图，它本身并不是函数，

是编译器用使用方式产生特定具体类型函数的模具。

所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。

比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

函数模板的实例化

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

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

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

如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

模板参数的匹配原则

一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。

对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。

但如果模板可以产生一个具有更好匹配的函数， 那么将选择模板。

模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

需要注意，所定义的一个模板只能够在一个类或者是一个函数中使用。不能支持同时又多个函数或者类使用同一个模板（可以理解为其是一次性的）

类模板

类模板的定义格式

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

比如:

template <class T>
class vector
{
    //...
}

需要注意：注意：vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具

另外还要注意：类模板中函数放在类外进行定义时，需要加模板参数列表。。

template <class T>
Vector<T>::~Vector()
{
    if(_pData)
    delete[] _pData;
    _size = _capacity = 0;
}

类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。