c++初阶--模板进阶
今天我们来学习一下和模板相关的一些知识。
目录
1. 非类型模板参数
1.1 非类型模板参数
1.2 使用非类型模板参数定义静态数组的好处
2. 模板的特化
2.1 函数模板的特化
2.2 类模板的特化
2.2.1 全特化
2.2.2 偏特化
3. 模板分离编译
3.1 什么是分离编译
3.2 模板的分离编译
1. 非类型模板参数
1.1 非类型模板参数
类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。
我们之前学习的模板容器使用的就是类型形参，而今天我们要学习另一种参数：非类型形参。
template< class T ,size_t N = 10 >
对于给出的一个模板定义，第一个参数就是类型参数，而第二个参数就是非类型参数，在定义中，N被定义为常量。
比如：
template
class one{
private:
int a[N];
} 我们使用模板声明了一个类，在类中有一个成员变量是整形数组，数组的大小是我们定义的常量N，我们给定了N一个缺省值10，当然也可以不给定，
template
class one{
private:
int a[N];
}
int main()
{
one<5> o1;
one<10> o2;
one<> o3;
return 0;
} 当我们不给定缺省值的时候，可以将类对象定义为o1，o2两个这样的形式，当给定缺省值的时候也可以写为o3这样的形式，则数组大小为成员变量的值。在c++20中，对于o3，也可以省略<>，写为one o3。
非类型模板参数只能定义整形常量，对于char short int long bool这几种类型，都可以作为非类型模板参数。在c++20中，也支持将double类型定义为非类型模板参数。
非类型模板参数在编译时就有结果，所以可以用来定义静态数组。
1.2 使用非类型模板参数定义静态数组的好处
1. 对于一个数组的越界检查，一个数组如果越界读，可以进行，但读出的结果是随机值；如果进行越界写，系统对于一个数组，在数组后面有两位标志位，这两位有一个默认值，当写的是这两位时，会判断是越界并进行报错，但写的若不是这两位，则不会进行报错。
namespace bite
{
// 定义一个模板类型的静态数组
template
class array
{
public:
T& operator[](size_t index) { return _array[index]; }
const T& operator[](size_t index)const { return _array[index]; }
size_t size()const { return _size; }
bool empty()const { return 0 == _size; }
private:
T _array[N];
size_t _size;
}；
} 但由于我们使用非类型模板参数定义的静态数组是在类中进行定义的，所以该静态数组有迭代器（指针），无论对于读还是写，只要越界就会进行报错。
2. 通过非类型模板参数定义的静态数组，和vector容器看起来没什么两样，相反vector还能进行扩容。但该静态数组的空间在栈上，而vector的空间是在堆上申请来的，所以静态数组的空间使用效率更高。
2. 模板的特化
template
bool Less(T left, T right)
{
return left < right;
}
int main()
{
cout << Less(1, 2) << endl; // 可以比较，结果正确
Date d1(2022, 7, 7);
Date d2(2022, 7, 8);
cout << Less(d1, d2) << endl; // 可以比较，结果正确
Date* p1 = &d1;
Date* p2 = &d2;
cout << Less(p1, p2) << endl; // 可以比较，结果错误
return 0;
} 对于第一组比较，我们使用的是内置类型，可以比较出两个数的大小；对于第二组比较，我们使用自定义类型Date，由于Date类中实现了运算符重载operator<和operator>，所以也能比较出两个日期的大小；对于第三组比较，我们给出的是两个日期类对象的地址，当然也可以比出大小，但比较出的是两个地址的大小，而不是日期的大小。
对于这样的特例，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。
2.1 函数模板的特化
函数模板特化的步骤：
1. 必须要先有一个基础的函数模板2. 关键字 template 后面接一对空的尖括号 <>3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型4. 函数形参表 : 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。
template
bool Less(T a, T b)
{
return a < b;
}
template<>
bool Less(Date* a, Date* b)
{
return *a < *b;
}
int main()
{
cout << Less(1, 2) << endl;
Date d1(2022, 7, 7);
Date d2(2022, 7, 8);
cout << Less(d1, d2) << endl;
Date* p1 = &d1;
Date* p2 = &d2;
cout << Less(p1, p2) << endl; // 调用特化之后的版本，而不走模板生成了
return 0;
} 我们对Less函数进行特化，使其当我们传Date*类型的参数时不会出错。
我们给函数传自定义类型的参数时，为了避免参数进行拷贝构造，通常会传入引用，对于函数模板的特化又应该写成怎样呢？
template<>
bool Less(Date* const & a, Date* const & b)
{
return *a < *b;
} 因为传给函数的参数是对象的引用，但我们给出的是对象的指针，所以const & 应该放在*之后，代表修饰的是指针指向的对象。
那么若是我们给出的Date* 也被const修饰了呢？
template<>
bool Less(const Date* const & a, const Date* const & b)
{
return *a < *b;
} 我们知道被const修饰之后，指针的权限变小了，所以需要一个新的特化：
template<>
bool Less(const Date* const & a, const Date* const & b)
{
return *a < *b;
} 由此可见，使用函数模板特化来处理这些问题还是很复杂的。
bool Less(Date* left, Date* right)
{
return *left < *right;
}2.2 类模板的特化
但如果我们定义一个仿函数Less来进行两个数的比较，对于给定的Date*类型的参数，还是会给出错误的结果，此时依旧要对类模板进行特化。
2.2.1 全特化
template
class one {
public:
one()
{
cout << "one" << endl;
}
private:
T1 o1;
T2 o2;
};
template<>
class one {
public:
one()
{
cout << "one" << endl;
}
private:
int o1;
char o2;
}; 对于全特化：
1. 必须要先有一个基础的类模板2. 关键字 template 后面接一对空的尖括号 <>3. 类 名后跟一对尖括号，尖括号中指定所有特化的类型
此时我们可以对仿函数Less进行特化使其也能解决Date*的问题：
template
struct Less {
public:
bool operator()(const T& t1, const T& t2)
{
return t1 < t2;
}
};
template<>
struct Less {
public:
bool operator()(Date* d1, Date* d2)const
{
return *d1 < *d2;
}
}; 此时就能得到正确答案。
2.2.2 偏特化
1. 部分特化：将模板参数类表中的一部分参数特化。2. 参数更进一步的限制：偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。
对于第一种部分特化：
template
class one {
public:
one()
{
cout << "one" << endl;
}
private:
T1 o1;
T2 o2;
};
template
class one {
public:
one()
{
cout << "one" << endl;
}
private:
T1 o1;
int o2;
}; 于先前不同的是，我们将不需要特化的参数依旧写在template<> 的括号里，在类名后面的括号里，将所有类型全部写下。
对于第二种参数更进一步的限制：
template
class one {
public:
one()
{
cout << "one" << endl;
}
private:
T1 o1;
T2 o2;
};
template
class one {
public:
one()
{
cout << "one" << endl;
}
private:
T1* o1;
T2* o2;
};
template
class one {
public:
one()
{
cout << "one" << endl;
}
private:
T1& o1;
T2& o2;
};
template
class one {
public:
one()
{
cout << "one" << endl;
}
private:
T1* o1;
T2& o2;
}; 可以将类型特化为指针类型或引用类型，也可以两种类型同时存在。
根据代码我们能看出，我们在template后面的括号里给出的是原类型，而不是指针或引用，这样我们在类中既可以使用原类型也可以使用指针或引用类型。
3. 模板分离编译
3.1 什么是分离编译
3.2 模板的分离编译
// a.h
template
T Add(const T& left, const T& right);
// a.cpp
template
T Add(const T& left, const T& right)
{
return left + right;
}
// main.cpp
#include"a.h"
int main()
{
Add(1, 2);
Add(1.0, 2.0);
return 0;
} 但这样是行不通的，我们知道源文件需要经历四步才能变成可执行文件：
1. 预处理：
头文件展开/宏替换/条件编译/去掉注释....2. 编译：
检查语法，生成汇编代码3. 汇编：
汇编代码转为二进制机器码4. 链接：
目标文件合并生成可执行程序，把所有函数地址链接在一起
但是在编译时，编译器需要知道模板的定义来实例化，而模板只在使用时实例化。当编译单独的cpp文件时，若模板实现未被引用，编译器不会生成对应的二进制代码，导致链接器无法找到符号地址，引发错误。
通产有两个解决方法：
1. 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的。推荐使用这种。2. 模板定义的位置显式实例化。这种方法不实用，不推荐使用。
到这里，c++的初阶全部学习完毕，下次再见面就是c++高阶的内容了。