【C++】学习笔记——模板

三、内存管理

4. operator new与operator delete函数

我们之前学到，new 和 delete 是用户进行动态内存申请和释放的操作符。那么 ，operator new 和 operator delete 是重载这两个操作符的吗？不是的，这两个其实是函数，底层是一样的，就算你使用 new 和 delete ，在底层都会转换成 operator new 和 operator delete 这俩函数。

#include<iostream>
using namespace std;
int main()
{
  int* p1 = new int;
  return 0;
}

那么 operator new 和 operator delete 又是什么？这两个函数其实是对 malloc 和 free 的封装，学过C语言的就知道，malloc 是有可能出现内存分配失败的情况的，此时，malloc 就会把指针赋值为 NULL ，我们需要手动检查才能发现，比较麻烦。而 operator new 函数则仅仅在内存分配失败的情况下 抛异常 。它本质上就是 malloc ，只是比 malloc 多了一个抛异常而且。

new 等价于 operator new + 构造函数；delete 等价于 析构函数 + operator delete 。注意：new[] 会去调用 operator new[] 函数，而 operator new[] 还是会去调用 operator new 函数。必须先析构再去释放空间，否则释放空间后找不到要析构的那块空间。

5. new 和 delete 的实现原理

1. 内置类型

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

2. 自定义类型

new的原理

调用operator new函数申请空间

在申请的空间上执行构造函数，完成对象的构造

delete的原理

在空间上执行析构函数，完成对象中资源的清理工作

调用operator delete函数释放对象的空间

new T[N]的原理

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

delete[]的原理

在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理

调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

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

四、模板初阶

1. 泛型编程

当我们要实现整形交换，浮点型交换以及字符型交换函数时，需要写出相应的函数，这些函数相似度极高，而且不够通用，其他类型的就不能使用，非常麻烦。

#include<iostream>
using namespace std;
void Swap(int& x, int& y)
{
  //
}
void Swap(double& x, double& y)
{
  //
}
void Swap(char& x, char& y)
{
  //
}
int main()
{
  return 0;
}

使用函数重载虽然可以实现，但是有一下几个不好的地方：①重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数②代码的可维护性比较低，一个出错可能所有的重载均出错。所以我们能不能使用一个模板，使其适用于所有类型呢？祖师爷就成功实现了这一壮举。

#include<iostream>
using namespace std;
// 函数模板
template<typename T>
void Swap(T& x, T& y)
{
  T tmp = x;
  x = y;
  y = tmp;
}
int main()
{
  int a = 1, b = 2;
  Swap(a, b);
  double c = 3.1, d = 4.2;
  cout << a << ' ' << b << endl;
  cout << c << ' ' << c << endl;
  return 0;
}

函数模板的格式是：

有个问题，有了函数模板后，每次调用函数，都是调用这个模板函数吗？NoNoNo，不是的，编译器会根据类型重新生成一个新的函数，再去调用这个新的函数。模板只是让本来要我自己写的函数由编译器自动生成。函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器 。世界是懒人创造的。

模板实例化

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

#include<iostream>
using namespace std;
// 这里 typename 也可以写成 class，都是一样的
template<class T>
T Add(const T& left, const T& right)
{
  return left + right;
}
int main()
{
  int a1 = 10, a2 = 20;
  double d1 = 10.0, d2 = 20.0;
  // 当这里存在两种类型时，就会发生报错
  Add(a1, d2);
  return 0;
}

怎么办呢？此时有两种处理方式：①用户自己来强制转化 ②使用显式实例化。

#include<iostream>
using namespace std;
// 这里 typename 也可以写成 class，都是一样的
template<class T>
T Add(const T& left, const T& right)
{
  return left + right;
}
int main()
{
  int a1 = 10, a2 = 20;
  double d1 = 10.0, d2 = 20.0;
  // 强转：
  Add(a1, (int)d2);
  // 显示实例化，主动告诉类型
  Add<int>(a1, d2);
  return 0;
}

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

当模板函数和同名的非模板函数同时存在时，优先使用非模板函数，当类型不匹配时才回去使用模板函数。注意！当调用函数时进行显示实例化的时候，则会强制调用模板函数。

#include<iostream>
using namespace std;
template<class T>
T Add(const T& left, const T& right)
{
  cout << "T Add()" << endl;
  return left + right;
}
int Add(const int& left, const int& right)
{
  cout << "int Add()" << endl;
  return left + right;
}
int main()
{
  int a1 = 10, a2 = 20;
  double d1 = 10.0, d2 = 20.0;
  // 强制使用模板函数
  cout << Add<int>(a1, d2) << endl;;
  return 0;
}

未完待续