目录
1. C++的动态内存管理
上一篇文章已经大致介绍完new和delete的用法，
以及C++和C语言两种动态内存管理方式的区别，这里简单总结一下：
1. 动态申请内置类型的数据：
new/malloc除了用法上面，其他方面没什么区别。
2. 动态申请自定义类型的数据：
new/malloc除了用法上面，new/delete还会调用构造函数初识化和析构函数。
2. new和delete的底层
来看：
我们可以看到，new和delete实际上是调用这两个全局函数：
operator new 和 operator delete，而这两个库函数其实我们也可以直接使用
来看代码：
#include <iostream>
using namespace std;
int main()
{
int* p1 = new int;
delete p1;
int* p2 = (int*)operator new(sizeof(int));
operator delete(p2);
return 0;
}我们可以看到，从用法上来看，这两个函数的用法是和malloc和free是一样的，
我这里在来看：
new的malloc之间的区别，
new的功能：开空间 + 构造函数
malloc功能：开空间
实际上，new的底层开空间就是直接使用的malloc，但是
面向对象的语言处理失败，不喜欢用返回值，更建议用抛异常，而malloc失败返回的是空，
所以实际上operator new是对malloc的一个封装，如果申请失败，operator new就会抛异常，
所以new就是使用operator new开空间 + 调用构造函数。
3. 定位new
定位new的作用是显示调用构造函数，
在平时，构造函数都是自动调用的，在创建对象的时候自动调用，
在使用new的时候也会自动调用构造函数，
来看这段代码：
#include <iostream>
using namespace std;
class A {
public:
A()
{
cout << "A()" << endl;
}
~A()
{
cout << "~A()" << endl;
}
};
int main()
{
A* p1 = new A;
delete p1;
//使用定位new模拟new的功能
A* p2 = (A*)malloc(sizeof(A));
new(p2)A;
p2->~A();
free(p2);
return 0;
}输出：
A()
~A()
A()
~A()定位new的用法就是这样：new(p2)A；new(指针)类型。
当然，如果需要传参也可以：new(p2)A(1)，这样给构造函数传参。
4. new和malloc 的区别总结
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在释放空间前会调用析构函数完成空间中资源的清理。
总结：
前四个是特性和用法之间的不同，
后面两个是底层实现的不同：返回值/抛异常，调用构造和析构函数
5. 模板
模板是个好东西，
我先来看这样一段代码：
#include <iostream>
using namespace std;
void Swap(int& x, int& y) {
int tmp = x;
x = y;
y = tmp;
}
void Swap(double& x, double& y) {
double tmp = x;
x = y;
y = tmp;
}
void Swap(char& x, char& y) {
char tmp = x;
x = y;
y = tmp;
}
int main()
{
return 0;
}我们在学了函数重载之后，可以通过这种方式，
让我们对这几个类型都能使用交换操作，但是，这样全部写一遍也太麻烦了，
这还只是三个类型，如果有更多的类型呢？
那该怎么办呢？
来看代码：
#include <iostream>
using namespace std;
//也可以这样写：template<class T>
template<typename T>
void Swap(T& x, T& y) {
T tmp = x;
x = y;
y = tmp;
}
int main()
{
int a1 = 10, b1 = 20;
double a2 = 1.1, b2 = 2.2;
char a3 = 'a', b3 = 'b';
Swap(a1, b1);
Swap(a2, b2);
Swap(a3, b3);
return 0;
}
使用了模板之后，就能支持所有类型的交换了，
模板的那个T就是模板参数，它定义的是类型。
这个时候又有一个问题了，那这三个Swap调用的是同一个函数吗?
我们来看看汇编怎么说：
发现没有，三个函数的地址是不同的，他们是调用的是三个不一样的函数，
因为这个Swap只是一个模板，他会根据你的调用生成对应的函数，
而这个过程称之为模板的实例化。
就像这张图一样：
所以实际上我们调用的还是这些具体的函数，
最终是编译器承担了这一切，承担了我们需要干的活。
写在最后：
以上就是本篇文章的内容了，感谢你的阅读。
如果感到有所收获的话可以给博主点一个赞哦。
如果文章内容有遗漏或者错误的地方欢迎私信博主或者在评论区指出~