【C++】模板2.0

最近学习了一些模板的知识，速写本博客作为学习笔记，若有兴趣，欢迎垂阅读！

1.非类型模板参数

模板参数分类类型形参与非类型形参。

类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

ps：

浮点数（C++20之前）、类对象以及字符串是不允许作为非类型模板参数的。
非类型的模板参数必须在编译期就能确认结果。

namespace hd
{// 定义一个模板类型的静态数组template<class T, size_t N = 10>//N就是非类型模板参数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;};
}int main()
{hd::array<int> ia;hd::array<char, 6> ca;return 0;
}

看到这个栗子，类模板参数N就是非类型模板参数。

库里面也有使用非类型模板参数的栗子，比如类模板array 的设计就使用了非类型模板参数，看到N就是这个类模板的非类型模板参数：

array也是一个容器，底层其实就是一个静态数组，关于其接口有兴趣的话可以自行去查阅。不过这个容器比较鸡肋吧，因为vector似乎更香。

当然，这个容器也有其优点：

普通数组对于越界访问的检查是一种抽查，越界访问了未必检查得出来。但array对于越界访问一查一个准，也许其底层实现加了断言吧，例如其成员函数operator[]完全可以加断言检查是否越界。
本容器对象一旦实例化，就不支持动态调整大小，因为其空间是静态开辟的静态数组。但是其空间是在栈区开辟的，而vector的空间是在堆区开辟的，是动态开辟的。

看到当非类型模板参数有缺省值的一些情况，实例化对象代码写法：

template<class T = int, size_t N = 10>
class a
{T _arr[N];
};
template<int N = 10>
class b
{int _arr[N];
};int main()
{a<> ap;b<> bp;return 0;
}

C++20以后也支持如下写法：

template<class T = int, size_t N = 10>
class a
{T _arr[N];
};
template<int N = 10>
class b
{int _arr[N];
};int main()
{a ap1;a<char> ap2;b bp;return 0;
}

2.模板的特化

2.1.模板特化的概念

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板

#include <iostream>
using namespace std;class Time
{int _h;int _m;int _s;
public:Time(int h, int m, int s):_h(h) ,_m(m) ,_s(s){}bool operator<(const Time& t)const{if (_h != t._h) return _h < t._h;else if (_m != t._m) return _m < t._m;return _s < t._s;}
};//专门比较小于的函数模板
template <class T>
bool Less(const T& t1, const T& t2)
{return t1 < t2;
}int main()
{Time t1(22, 22, 22);Time t2(11, 11, 11);cout << Less(t1, t2) << endl;//结果正确cout << Less(&t1, &t2) << endl;//结果错误return 0;
}

可以看到，Less绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，&t2指向的t2显然小于&t1指向的t1对象，但是Less内部并没有比较&t2和&t1指向的对象内容，而比较的是&t1和&t2本身的值，这就无法达到预期而错误。

此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

2.2.函数模板特化

函数模板的特化步骤：

1. 必须要先有一个基础的函数模板

2. 关键字template后面接一对空的尖括号<>

3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型

4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

#include <iostream>
using namespace std;class Time
{int _h;int _m;int _s;
public:Time(int h, int m, int s):_h(h) ,_m(m) ,_s(s){}bool operator<(const Time& t)const{if (_h != t._h) return _h < t._h;else if (_m != t._m) return _m < t._m;return _s < t._s;}
};//专门比较小于的函数模板
template <class T>
bool Less(const T& t1, const T& t2)//注意这里const修饰的是引用，而不是修饰类型
{return t1 < t2;
}//Less函数模板的特化
template<>
bool Less<Time*>(Time* const & t1, Time* const & t2)
{return *t1 < *t2;
}int main()
{Time t1(22, 22, 22);Time t2(11, 11, 11);cout << Less(t1, t2) << endl;//走模板生成cout << Less(&t1, &t2) << endl;//调用特化之后的版本，而不走模板生成了return 0;
}

但是但是，一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出，而不是去特化函数模板，例如：

#include <iostream>
using namespace std;class Time
{int _h;int _m;int _s;
public:Time(int h, int m, int s):_h(h), _m(m), _s(s){}bool operator<(const Time& t)const{if (_h != t._h) return _h < t._h;else if (_m != t._m) return _m < t._m;return _s < t._s;}
};//专门比较小于的函数模板
template <class T>
bool Less(const T& t1, const T& t2)//注意这里const修饰的是引用，而不是修饰类型
{return t1 < t2;
}//现成函数（非函数模板特化）
bool Less(Time* t1, Time* t2)
{return *t1 < *t2;
}int main()
{Time t1(22, 22, 22);Time t2(11, 11, 11);cout << Less(t1, t2) << endl;//走模板生成cout << Less(&t1, &t2) << endl;//调用现成函数return 0;
}

直接将类型是Time*类型比较的函数给出，不是香喷喷吗？何必走函数模板特化呢？所以函数模板不建议特化。

2.3.类模板特化

类模板特化分为全特化和半特化（偏特化）。

2.3.1.全特化

#include <iostream>
using namespace std;
template<class T1, class T2>
class Data
{
public:Data() { cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;
};//类模板全特化，当第1个模板参数为int且第2个模板参数为char时，调用
template<>
class Data<int, char>
{
public:Data() { cout << "Data<int, char>" << endl; }
private:int _d1;char _d2;
};
int main()
{Data<int, int> d1;Data<int, char> d2;return 0;
}

2.3.2.半特化（偏特化）

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。偏特化有以下两种表现方式：

部分特化

将模板参数类表中的一部分参数特化。

#include <iostream>
using namespace std;
template<class T1, class T2>
class Data
{
public:Data() { cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;
};//类模板半特化，只要第2个类模板参数为int，调用
template<class T1>
class Data<T1, int>
{
public:Data() { cout << "Data<T1, int>" << endl; }
private:T1 _d1;int _d2;
};
int main()
{Data<int, int> d1;Data<int, char> d2;return 0;
}

参数更进一步的限制

偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

#include <iostream>
using namespace std;
template<class T1, class T2>
class Data
{
public:Data() { cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;
};//类模板半特化，两个参数偏特化为指针类型，只要2个类模板参数为指针，调用
template<class T1, class T2>
class Data<T1* , T2*>
{
public:Data() { cout << "Data<T1* , T2*>" << endl; }
private:T1 _d1;T2 _d2;
};
int main()
{Data<int, int> d1;Data<int*, char*> d2;return 0;
}

3.模板分离编译

3.1.什么是分离编译

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

3.2.模板的分离编译

模板是不推荐分离编译的，也就是说模板不推荐声明和定义分离到不同文件下，如果分离了会出现链接问题。例如：

一个工程，有3个文件，分别是a.h、a.cpp、test.cpp。

a.h：

#pragma once//a类模板声明
template <class T>
class a
{T _tmp;
public:a(const T& tmp = T());const T& get_tmp();
};//Add函数模板声明
template<class T>
T Add(const T& n1, const T& n2);

a.cpp：

#include "a.h"//a类模板定义
template<class T>
const T& a<T>::get_tmp()
{return _tmp;
}template<class T>
a<T>::a(const T& tmp):_tmp(tmp)
{}//Add函数模板定义
template<class T>
T Add(const T& n1, const T& n2)
{return n1 + n2;
}

test.cpp：

#include <iostream>
using namespace std;
#include "a.h"int main()
{a<int> x(10);cout << x.get_tmp() << endl;cout << Add(1, 2) << endl;return 0;
}

这3个文件中有2个模板，声明和定义都分离了。编译会出现问题：

如何解决？

2个办法：

将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的，也就是说模板的声明和定义不要分离到不同文件。推荐使用这种办法。
模板定义的位置显式实例化。这种方法不实用，不推荐使用，如下：

a.cpp：

#include "a.h"//a类模板定义
template<class T>
const T& a<T>::get_tmp()
{return _tmp;
}template<class T>
a<T>::a(const T& tmp):_tmp(tmp)
{}//Add函数模板定义
template<class T>
T Add(const T& n1, const T& n2)
{return n1 + n2;
}//显示实例化
template
class a<int>;//显示实例化
template
int Add(const int& n1, const int& n2);