目录
一，回望C语言内存
二， C++ 内存管理方式
1. 内置类型
2. 自定义类型
3. new & malloc 返回内容区别
4. operator new & operator delete
5. malloc/free和new/delete的区别总结
6. 定位new表达式(placement-new) （了解）
三，模板初阶
1. 泛型编程——概念
2. 函数模板
（1. 模板实例化
概念
（2. 显式实例化
（3. 隐式实例化
3. 类模板——【练习】实现栈的Push
一，回望C语言内存
尝试给出下面答案：
结果：
解析：
二， C++ 内存管理方式
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的
内存管理方式：
通过new和delete操作符进行动态内存管理。
1. 内置类型
对于内置类型 new / delete 与 malloc & free 没有本质的区别
void Test()
{ // 申请一个int空间
int* z1 = new int;
// 申请5个int的数组
int* z2 = new int[5];
// 申请一个int空间，初始化为5
int* z3 = new int(5);
// 销毁
delete z1;
delete[] z2; // 销毁类型要匹配
delete z3;
// 对于内置类型 new / delete 与 malloc & free 没有本质的区别
// 仅仅new只是用法上简化了
}注意： C++里面没有支持 C语言 realloc 的创新，C++接口不支持扩容。
2. 自定义类型
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
来释
放空间
struct B
{
public:
B(int b)
{
k = b;
cout << "B" << endl;
}
~B()
{
cout << "~B" << endl;
}
private:
int k;
};
struct A
{
public:
A(int sum, int b)
: _sum(sum)
, _b(b)
{
cout << "A" << endl;
}
~A()
{
cout << "~A" << endl;
}
private:
int _sum;
B _b;
};
int func()
{
A* p1 = new A(10, 20); // 1.内置类型初始化 2. 自定义类型调用其构造函数
A* p2 = new A[10];
A* p3 = new A[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // 多实例,并且初始化
delete p1; // 1. 销毁内置类型 2. 调用析构函数
delete[] p2; // 销毁类型一定要匹配使用, 否则可能出现报错
delete[] p3;
return 0; // 返回码
}3. new & malloc 返回内容区别
（1） malloc 失败 返回 null 指针
（2） new 失败 会返回异常 （异常后面再着重开始讲）
void test()
{
try // 其中如果new失败会进入异常，也就是catch
{
// 当内存申请超过一定限度，会申请失败
// malloc 失败会返回null
char* p1 = (char*)malloc(sizeof(char) * 1024u * 1024u * 1024u * 1024u * 1024 * 1024);
printf("%p\n", p1);
// new 失败会抛异常
char* p2 = new char[1024 * 1024 * 1024 * 1024 * 1024 * 1024];
printf("%p\n", p2);
free(p1);
delete[] p2;
}
catch (const std::exception& e) // 打印最近的异常信息
{
cout << e.what() << endl;
}
}注意： 面对new 失败返回异常 会用一个try 来包含 需要new 的代码。
4. operator new & operator delete
new和delete是用户进行
动态内存申请和释放的操作符，
operator new 和operator delete是系统提供的
全局函数，
new在底层调用operator new全局函数来申请空间，
delete在底层通过 operator delete全局函数来释放空间。
(总得来说 operator new & delete,并不是函数重载，而是帮助new，delete实现其机制的全局函数)
operator new： 该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。( new -> operator new -> malloc -> 指针 或 异常 ）
operator delete: 该函数最终是通过free来释放空间的。
5. 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在释放空间前会调用析构函数完成空间中资源的清理。
6. 定位new表达式(placement-new) （了解）
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象
如： new (p1) A (10) // 其中 p1 通过malloc已开辟空间但未初始化，A是类型 ， 10是调用自定义构造函数初始化的值。
使用场景：
定位new表达式在实际中一般是配合
内存池（后面我们再提）使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。
struct B
{
public:
B(int b)
{
k = b;
cout << "B" << endl;
}
~B()
{
cout << "~B" << endl;
}
private:
int k;
};
void test1()
{
B* p3 = (B*)malloc(sizeof(B));
// malloc 的空间并未初始化
new (p3) B(100); // 给构造函数参数 100
p3->~B();
delete p3;
}
三，模板初阶
1. 泛型编程——概念
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定
类型版本。
我们肯定写过这样的编程
void Swap(int& z1, int& z2)
{
int tmp = z2;
z2 = z1;
z1 = tmp;
}交换函数，一般只能处理一种数据； 而一个程序需要交换多种类型数据，这样我们需要创建多种类型交换函数，这个过程是重复，低效的。
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
2. 函数模板
原理：函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模
板就是将本来应该我们做的重复的事情交给了编译器。
编译器使用模板步骤：
1. 推演 类型
2. 模板实例化
下面简单展示一下：
template <class T> // 或者 <template T> T只是取名字
void Swap(T& z1, T& z2)
{
T tmp = z2;
z2 = z1;
z1 = tmp;
}
int main()
{
int i = 1, b = 2;
Swap(i, b);
return 0;
}在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，同理这就是我们交换函数的模板， 中间编译器会进行推导类型，编译更复杂，时间会稍久一些。
注意：交换用的是同一套模板，但调用的函数并不是同一个函数。（编译器自动帮我们创建不同类型的交换函数）
关键的来了： 以后不需要自己创建交换函数，C++库中有一套交换函数，在std 命名空间里面。
操作如下：
#include <iostream>
using namespace std;
int main()
{
int i = 1, b = 2;
double z = 1.1, k = 2.2;
swap(i, b); // 小写就行
swap(z, k); // 模板推导，需要类型相同，否则报推导类型不确定
return 0;
}（1. 模板实例化
概念
用不同类型的参数使用函数模板时，称为函数模板的
实例化。 模板参数实例化分为
：
隐式实例化
和
显式实例化
。
（2. 显式实例化
在函数名后的<>中 指定模板参数 的实际类型
template <class T> // 或者 <template T>
T* func1(int n)
{
T* k1 = new T(n);
}
int main(void)
{
int a = 10;
double b = 20.0;
// 显式实例化
Add<int>(a, b); 1. 普通
func1<A>(10); 2. 特殊，必须要显式否则怎么推演？计算机：二进制给你，你来推演！
return 0;
}（3. 隐式实例化
让编译器根据实参 推演模板 参数的实际类型
#include <iostream>
using namespace std;
int ADD(size_t & z1, size_t & z2) // size_t是标准C库中定义的，它是一个基本的与机器相关的无符号整数的C/C + +类型
// 就简单理解为 unsiged int 主要防止 负数
{
return z1 + z2;
}
template <class T> // 或者 <template T>
T ADD(const T& z1, const T& z2)
{
return z1 + z2;
}
template <class B1, class B2> // 可以提供多个模板
B1 ADD(B1& b1, B2& b2)
{
return b1;
}
int main()
{
// 隐式实例 ——通过编译器自动推导， 不人为干预。
int i = 1, b = 2;
double z = 1.1, k = 2.2;
cout << ADD(i, (int)z) << endl; // 模板 不支持1.1 -> 1 隐式转化，但可以提前，进入的是
cout << ADD(1.2, (double)1) << endl;
// 思考；调用哪一个函数
cout << ADD(i, b) << endl; // 计算机会调用现成的函数，
// 调用 int ADD(int& z1, int& z2) ; 模板实例化需要通过编译器，所以优先级比较低。
cout << ADD(z, i) << endl; // 两种类型，则会选择多类型模型 B1 ADD(B1& b1, B2& b2)
return 0;
}3. 类模板——【练习】实现栈的Push
#include <iostream>
using namespace std;
#include <assert.h>
template <class T>
class stack
{
public:
stack(int capacity = 4)
: _size(0)
, _capacity(capacity)
, plist(nullptr)
{
plist = new T[_capacity];
}
void Push(T x)
{
assert(plist);
if (_size == _capacity)
{
// 1. 开空间
// 2. 拷贝旧数据
T* tmp = new T[_capacity * 2];
if (plist) // plist 首先是空指针，如果是是第一次不需要拷贝旧数据
{
memcpy(tmp, plist, sizeof(T) * _capacity);
// 如果申请成功
_capacity *= 2;
delete[] plist;
plist = tmp;
}
}
plist[_size++] = x;
cout << plist[_size - 1] << endl;
}
void Pop()
{
assert(_size > 0)
_size--;
}
const T& TopStack() // 返回栈顶元素，用的是引用，可以修改 私密成员，所以需要const修饰
{
assert(_size > 0); // 防止栈为空
return plist[_size - 1];
}
~stack()
{
delete[] plist;
_size = _capacity = 0;
}
private:
T* plist;
int _size;
int _capacity;
};
void func()
{
try
{
stack<int> p1; // 其中如果new失败会进入异常，也就是catch
stack<char> p2;
p1.Push(1);
p1.Push(2);
p1.Push(3);
p1.Push(4);
p1.Push(5);
cout << p1.TopStack() << endl;
}
catch (const std::exception& e)
{
cout << e.what() << endl; // 打印最近的异常信息
}
}总结：
- 类模板定义与声明不能分离（同文件允许分离），否则会报错。
- 一般类实例化时，不带类类型，所以一般类模板都要使用显示实例化。
- 在C++中，类模板在头文件中定义，因此可以写成“ .hpp”的头文件，意思是不仅有声明而且还有实现，一般是类模板实现。
结语
本小节就到这里了，感谢小伙伴的浏览，如果有什么建议，欢迎在评论区评论；如果给小伙伴带来一些收获请留下你的小赞，你的点赞和关注将会成为博主创作的动力。
