- 作者: 雪山肥鱼
- 时间：20211218 16:45
- 目的: 函数模板
# 函数模板的实例化
# 函数模板参数推断
# 各种推断比较与空模板参数列表推断
# 函数模板的重载
# 泛化与特化
## 全特化
## 偏特化
# 函数模板的默认参数
# 非类型模板参数
函数模板的实例化
template<typename T>
T Sub( T tv1, T tv2)
{
return tv1 - tv2;
}
int main( ) {
int sub = Sub(3, 5);
cout << "int sub v1 = " << sub << endl;
double sub2 = Sub(4.7, 3.1);
cout << "double sub v2 = " << sub2 << endl;
Sub<double>(3,5)； 会自动看成double类型
}
函数模板可以兼容多个类型，如上所示。实际上在编译阶段是实例化出来两个函数：
//"int __cdecl _nmsp1::Sub<int>(int,int)" 实例化后的函数名
//"double __cdecl _nmsp1::Sub<double>(double,double)
然而不合理的实例化依旧是有问题的，比如类型传入的是 string，编译期间就会报错。
string a("abc"), b("efg");
string addresult = Sub(a, b); //自动推断，不合法
编译阶段，编译器会查看函数模板的函数体部分，来确定针对类型 string，是否能进行运算。string + 可以，但不可以做减法运算。
实例化后，编译器在后续工作需要找到函数模板的函数体部分，正常项目中需要把函数模板宝库函数体写道一个.h or .hpp 中，与其他函数声明略有不同
函数模板参数推断
template<typename V, typename T, typename U>
V Add（T tv1, U tv2）{
return tv1 + tv2;
}
int main() {
cout << Add(15,17.8)<<endl;
}
上述代码编译错误：无法推断 计算结果U 的类型，也就是说，编译阶段只管编译的事情，无法推导出 15 + 17.8 的结果 和 类型。
cout<<Add<double>(15,17,7)<<endl；
double 指定的的是第一个 typename 的类型。模板的默认参数，是从前往后。与普通函数不同。
各种推断的比较以及空模板参数列表推断
template<typename T>
T mydouble(T tmpvalue) {
return tmpvalue + 2;
}
double mydouble(double tmpvalue) {
return tmpvalue + 2;
}
int main(int argc, char ** argv) {
//1.自动推断:
cout << mydouble(15) << endl;
//2. 指定类型模板参数
int result2 = mydouble<int>(16.9);//有警告，但没有错误，16.9
cout << result2 << endl;//数据会丢.
//3. 指定空模板参数类型
auto result3 = mydouble<>(16.9);//空的<>没有用，但语法允许，使用场景。
//有另一个mydouble 函数，因为优先调用普通函数，所以指定<> 让其调用函数模板
cout << result3 << endl;
return 0;
}
模板与普通函数同名，优先调用普通函数
模板的重载
template<typename T>
void myfunc(T tmpvalue) {
cout << "myfunc(T tmpvalue)" << endl;
}
template<typename T>
void myfunc(T * tmpvalue) {
cout << "myfunc(T * tmpvalue)" << endl;
}
void myfunc(int tmpvalue) {
cout<< "myfunc(int tmpvalue)" << endl;
}
int main(int argc, char ** argv) {
myfunc(12);//有普通函数重载，优秀选择普通函数
char *p = nullptr;
myfunc(p); //调 T *
myfunc(12.1);
return 0;
}
当模板遇到普通函数时，还是优先调用普通函数。
泛化与特化
泛化，就是常规的函数模板
特化，往往从泛化抽出来一组子集
先得有泛化，才能有特化
全特化
template<typename T, typename U>
void tfunc(T & tmprv, U & tmprv2) {
cout << "tfunc 泛化版本" << endl;
cout << tmprv << endl;
cout << tmprv2 << endl;
}
// int ,double 可以省略
template<>
void tfunc<int, double>(int & tmprv, double & tmprv2) {
cout << "---------------begin------------------" << endl;
cout << "特化版本" << endl;
cout << tmprv << endl;
cout << tmprv2 << endl;
cout << "-------------------end------------------" << endl;
}
int main(int argc, char **argv) {
const char* p = "I love china";
int i = 12;
//T:const char *, U:int
//tmprv: const char * &, tmprv2 :int &
tfunc(p, i);
int k = 12;
double db = 12.4;
tfunc(k, db);
return 0;
}
全特化 约等于 实例化了一个函数模板，并不等于 函数重载，效果差不多，但如果同时存在，依旧会优先选择普通函数。
编译器参考优先级:
- 普通函数
- 特化版本
- 函数模板
偏特化
函数模板的偏特化与类模板的偏特化是很不相同的。
- 数量上的偏特化
// 当然必须先有泛化，才能有特化
template<typename T, typename U>
void tfunc(T & tmp1, U& tmp2) {
cout << "tfunc 泛化版本" << endl;
cout << tmp1 << endl;
cout << tmp2 << endl;
}
/*编译错误*/
template<typename U>
void tfunc<double, U>(double & tmp1, U & tmp2) {
}
/*编译错误*/
template<typename T, typname U>
void tfunc<double, U>(double & tmp1, U &tmp2) {
}
//只有通过重载（无模板参数）
template<typename U>
void tfunc(double & tmp1, U & tmp) {
}
- 范围上的偏特化
范围上指的是: int -> const int 类型变小。
T -> T*, T-> T&, T-> T&&(右值引用)
以上范围 其实都是一直在缩小。
实际上，对于函数模板来讲，也不存在模板参数范围上的偏特化，依然用重载的方式解决。
template<typename T, typename U>
void tfunc(T & tmp1, U& tmp2) {
cout << "tfunc 泛化版本" << endl;
cout << tmp1 << endl;
cout << tmp2 << endl;
}
template<typename T, typename U>
void tfunc(const T & tmp1, U &tmp2) {
}
上者是两个函数，是重载。
尽量别考虑函数的偏特化，采用重载
函数模板的默认参数
默认 可不是 偏特化！
int mf(int tmp1, int tmp2) {
return 1;
}
int mf2(int tmp1, int tmp2) {
return 2;
}
typedef int(*FunType) (int ,int);
template<typename T, typename F = FunType>
void testFun(T i, T j, F function = mf) {
cout<<mf(i, j)<<endl;
}
int main() {
testFunc(10, 12);
testFunc(13, 14, mf2);
testFunc2(15, 16);
return 0;
}
当然函数模板的默认参数是可以写在前面的，不像类模板只能写在后面
template<typename F = FunType, typename T>
void testFunc2(T i, T j, F function = mf) {
cout << mf(i, j) << endl;
}
非类型模板参数
类型模板参数，即typename T， T本身代表了某种类型。
非类型模板参数，即普通类型：
//template<typename T, typname U, auto val = 100>
template<typename T, typename U, int val = 100>
auto add(T t1, U u1) {
return t1 + u1 + val;
}
int main() {
cout << add<float, float>(22.1f, 11.0f) << endl;
cout << add<float, float, 800>(22.1f, 11.0f) << endl;
//编译错误，k 是变量，编译期间并不知道
/*
int k = 1000;
cout << add<float, float, k>(22.1f, 11.0f) << endl;
*/
return 0;
}
非类型模板参数 一定要是常量，否则编译不过，因为编译期间 不知道变量的值。当然也可以用auto 进行推断。
并不是所有类型都可以当作非类型模板参数
int 可以，double，float 等不行，但是指针是可以的
- 整形
- 指针类型
- 左值，引用
- auto or decltype(auto)
- typename
有时候会看到如下写法
template<typename T, typename U, typename int val =100>
int 前面的typename ，相当于说明 int 是一个类型。
