【C++】模版进阶
我们在之前的博客中讲述过模版的使用：【C++】模版初阶，但这只是模版最基本的使用，下面再深入模版，看看还有另外什么用法：
目录
一、非类型模板参数
二、模板的特化
2.1 什么是模版的特化
2.2 函数模版的特化
2.3 类模版的特化
2.3.1 全特化
2.3.2 偏特化
三、模板的分离编译
3.1 解决方法
一、非类型模板参数
我们知道模版可以传递类型参数，除此之外还可以传递非类型参数：
例如：
#define N 10
template<class T>
struct Static_sequence
{
T a[N];
};上诉代码可以建立一个任意类型的静态顺序表，但是N值是确定的，我们如何建立我们想要的大小的静态顺序表呢？
再来看看下面的代码：
template<class T, size_t N = 10>
struct Static_sequence
{
T a[N];
};我们在模版上再加一个非类型参数size_t N，这个参数可以传入我们需要的值来初始化静态顺序表：
int main()
{
Static_sequence<int, 20> q;
return 0;
}在上述代码中我们传入了一个20，可以看到开辟了一个20个元素的静态数组：
对于该非类型模板参数，我们只能设定整型家族（int/char/short/...），对于其他类型是不支持的，例如：
对于设定的非类型模板参数，系统是将其作为常量看待的，所以它可以初始化数组元素个数
例如我们想要对传入的值做修改：
编译器是不能通过的
二、模板的特化
2.1 什么是模版的特化
通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：指针类型的比较：
class Date
{
friend ostream& operator<<(ostream& out, const Date& d);
public:
Date(int year, int month, int day)//构造函数
{
if (month < 1 || month>12 || (day<1 || day>GetMonthDay(year, month)))//判断日期是否合法
{
cout << "Illegal date!" << endl;
}
else
{
_year = year;
_month = month;
_day = day;
}
}
int GetMonthDay(int year, int month) const//获取year年month月的天数
{
int MonthDay[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 };//用数组来依次存储平年1到12月的天数
if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))//判断是否为闰年的2月
{
return 29;
}
return MonthDay[month - 1];
}
//运算符重载
bool operator==(const Date& d) const//判断日期是否相同
{
return _year == d._year && _month == d._month && _day == d._day;
}
bool operator!=(const Date& d) const//判断日期是否不相同
{
return !(*this == d);
}
bool operator<(const Date& d) const//判断当前日期是否在传入日期之前
{
return _year < d._year || (_year == d._year && _month < d._month) || (_year == d._year && _month == d._month && _day < d._day);
}
bool operator<=(const Date& d) const//判断当前日期是否在传入日期之前或相同
{
return (*this < d) || (*this == d);
}
bool operator>(const Date& d) const//判断当前日期是否在传入日期之后
{
return !(*this <= d);
}
bool operator>=(const Date& d) const//判断当前日期是否在传入日期之后或相同
{
return !(*this < d);
}
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "/" << d._month << "/" << d._day << endl;
return out;
}
// 函数模板 -- 参数匹配
template<class T>
bool Less(const T x, const T y)
{
return x < y;
}
int main()
{
std::cout << Less(Date(2022, 9, 27), Date(2022, 9, 25)) << endl;//Date类型比较
std::cout << Less(new Date(2022, 10, 27), new Date(2022, 10, 25)) << endl;//Date指针类型比较
return 0;
}比较结果：
因为我们在Date类中运算符重载了<的比较方法，所以对于Date类可以直接调用该方法进行比较，但是对于Date*类型，模版找不到比较方法，只能默认比较地址空间的大小，导致了结果的错误
为了解决该问题，我们引入模版的特化：
2.2 函数模版的特化
函数模板的特化步骤：
1.必须要先有一个基础的函数模板
2.关键字template后面接一对空的尖括号<>
3.函数名后跟一对尖括号，尖括号中指定需要特化的类型
4.函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误
下面我们对上面的模版函数进行指针的特例化：
// 函数模板 -- 参数匹配
template<class T>
bool Less(const T x, const T y)
{
return x < y;
}
// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* x, Date* y)
{
return *x < *y;
}这下结果就正确了：
该种实现简单明了，代码的可读性高，容易书写，因为对于一些参数类型复杂的函数模板，特化时要特别给出，因此函数模板不建议特化，平时我们使用实例化解决即可
2.3 类模版的特化
2.3.1 全特化
我们来设置一个类模版：
// 类模板 -- 参数匹配
template<class T>
class Less
{
bool operator()(T& x, T& y)
{
return x < y;
}
};
//全特化
template<>
class Less<Date*>
{
bool operator()(Date* x, Date* y)
{
return *x < *y;
}
};全特化即是将模板参数列表中所有的参数都确定化，在上述代码中我们将T类型指明为Date*类型，这种将模板参数列表全部指明为一个确定的类型的操作就是全特化
2.3.2 偏特化
偏特化就是任何针对模版参数进一步进行条件限制设计的特化版本
如下：我们将类模板参数进一步限制为指针类型，但具体为上面类型的指针并未说明：
// 类模板 -- 参数匹配
template<class T>
class Less
{
bool operator()(T& x, T& y)
{
return x < y;
}
};
//偏特化，对模版参数进一步进行条件限制
template<class T>
class Less<T*>
{
bool operator()(T* x, T* y)
{
return *x < *y;
}
};// 类模板 -- 参数匹配
template<class T1, class T2>
class Data
{
public:
Data() { cout << "Data<T1, T2>" << endl; }
private:
T1 _d1;
T2 _d2;
};
//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{
public:
Data() { cout << "Data<T1*, T2*>" << endl; }
private:
T1 _d1;
T2 _d2;
};
//两个参数偏特化为引用类型
template <typename T1, typename T2>
class Data <T1&, T2&>
{
public:
Data(const T1& d1, const T2& d2)//参数偏特化为引用类型时一定要初始化
: _d1(d1)
, _d2(d2)
{
cout << "Data<T1&, T2&>" << endl;
}
private:
const T1& _d1;
const T2& _d2;
};
//一个参数偏特化为引用类型,一个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1&, T2*>
{
public:
Data(const T1& d1, const T2* d2)//参数偏特化为引用类型时一定要初始化
: _d1(d1)
{
cout << "Data<T1&, T2*>" << endl;
}
private:
const T1& _d1;
T2* _d2;
};注意：参数偏特化为引用类型时一定要初始化（使用初始化列表和缺省参数都可）
偏特化有还有另一种表现方式： 当模版参数有多个时，部分特化一部分参数
例如：
// 类模板 -- 参数匹配
template<class T1, class T2>
class Data
{
public:
Data() { cout << "Data<T1, T2>" << endl; }
private:
T1 _d1;
T2 _d2;
};
// 偏特化,不改变第一个模版参数，将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:
Data() { cout << "Data<T1, int>" << endl; }
private:
T1 _d1;
int _d2;
};三、模板的分离编译
我们现在使用声明和实现分离的编译的方法来实现一个函数模版（将类模版的声明放在Func.h头文件中，实现代码放在Func.cpp中）：
Func.h：
#pragma once
template<class T>
T Add(const T& left, const T& right);Func.cpp：
#include"Func.h"
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}test.cpp：
#include"Func.h"
int main()
{
int x = 5, y = 10;
Add<int>(x, y);
return 0;
}我们来编译一下：
咦，怎么编译通过不了？还报了一个链接错误？
下面我们来仔细分析一下：
一份C/C++程序要运行，一般要经历一下步骤:预处理—-->编译--->汇编―—-->链接，不熟悉的同学可以看到这里：C语言程序环境_c语言程序运行环境
但是在每个cpp文件经过预处理、编译、汇编，但没有进入链接阶段之前，都是单独被编译器所编译的。这样会导致由于模版参数没有实例化，Func.cpp文件在形成汇编指令时，并没有为Add函数开辟函数栈帧（因为没有参数的实例化，系统压根就不知道要开辟多大的空间来给Add函数用），但是由于头文件的展开，使汇编会形成call指令（这时的call指令并没有填上Add函数所在的栈帧地址），所以最终形成的obj文件进入链接时，会发现Func.cpp形成的obj文件中并没有上Add函数所在的栈帧地址，此时call指令中没有实际地址导致指令无法正常执行，最后报错
3.1 解决方法
知道了上面的原理后，我们就可以得出相应的解决办法了：
1. 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的。推荐使用这种。
2. 模板定义的位置显式实例化。但我们不能给每个类型参数都实例化一份代码吧，这样要模版参数还有什么意义呢？所以这种方法不实用，不推荐使用