函数模板
● 函数模板的 ( 完全 ) 特化： template<> void f(int) / template<> void f(int)
– 并不引入新的（同名）名称，只是为某个模板针对特定模板实参提供优化算法
函数模板的特化本质上是实例化，有时实例化和特化会混用，但是函数模板的实例化是引入一个实例，而函数模板特化是为某些模板参数引入特别的实现。
– 注意与重载的区别
函数模板的重载
template<typename T>
void fun(T x)
{
//std::cout << x << std::endl;
}
template<typename T>
void fun(T* x)
{
//std::cout << x << std::endl;
}
函数模板的特化
template<typename T>
void fun(T* x)
{
//std::cout << x << std::endl;
}
template<>
void fun(int* x)
{
//std::cout << x << std::endl;
}
– 注意特化过程中的模板形参推导
● 避免使用函数模板的特化（Calling Functions : A Tutorial）
template<typename T>
void fun(T x) //#1
{
std::cout << "template<typename T> void fun(T x)" << std::endl;
}
template<typename T>
void fun(T* x) //#2
{
std::cout << "template<typename T> void fun(T* x)" << std::endl;
}
template<>
void fun(int* x) //同template<> void fun<int>(int* x)，是#2函数模板的特化
{
std::cout << "template<> void fun(int* x)" << std::endl;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
int x;
fun(&x);
return a.exec();
}
template<typename T>
void fun(T x) //#1
{
std::cout << "template<typename T> void fun(T x)" << std::endl;
}
template<typename T>
void fun(T* x) //#2
{
std::cout << "template<typename T> void fun(T* x)" << std::endl;
}
template<>
void fun<int*>(int* x) //是#1函数模板的特化
{
std::cout << "template<> void fun<int*>(int* x)" << std::endl;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
int x;
fun(&x); //调用#2函数模板产生的实例化的版本
return a.exec();
}
template<typename T>
void fun(T x) //#1
{
std::cout << "template<typename T> void fun(T x)" << std::endl;
}
template<>
void fun(int* x) //注意这个特化放在#1函数模板的后面，所以它是#1函数模板的特化
{
std::cout << "template<> void fun(int* x)" << std::endl;
}
template<typename T>
void fun(T* x) //#2
{
std::cout << "template<typename T> void fun(T* x)" << std::endl;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
int x;
fun(&x); //调用#2函数模板的一个实例化版本
return a.exec();
}
– 不参与重载解析，会产生反直觉的效果
– 通常可以用重载代替
template<typename T>
void fun(T x)
{
std::cout << "template<typename T> void fun(T x)" << std::endl;
}
void fun(int* x) //参与了重载解析，引入了新的名称，这种情况下fun函数有三个版本
{
std::cout << "void fun(int* x)" << std::endl;
}
template<typename T>
void fun(T* x)
{
std::cout << "template<typename T> void fun(T* x)" << std::endl;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
int x;
fun(&x); //调用void fun(int* x)
return a.exec();
}
template<typename T>
void fun(T x)
{
std::cout << "template<typename T> void fun(T x)" << std::endl;
}
template<typename T>
void fun(T* x)
{
std::cout << "template<typename T> void fun(T* x)" << std::endl;
}
void fun(int* x) //参与了重载解析，引入了新的名称，这种情况下fun函数有三个版本
{
std::cout << "void fun(int* x)" << std::endl;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
int x;
fun(&x); //调用void fun(int* x)
return a.exec();
}
– 一些不便于重载的情况：无法建立模板形参与函数形参的关联
template<typename T, typename Res>
Res fun(T x)
{
std::cout << "template<typename T, typename Res> Res fun(T x)" << std::endl;
return Res{};
}
● 使用 if constexpr 解决
#include<type_traits>
template<typename Res, typename T>
Res fun(T x)
{
if constexpr(std::is_same_v<Res, int>)
{
std::cout << "1" << std::endl;
}
else
{
std::cout << "2" << std::endl;
}
return Res{};
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
int x;
fun<int>(&x); //输出1
return a.exec();
}
#include<type_traits>
template<typename Res, typename T>
Res fun(T x)
{
if constexpr(std::is_same_v<Res, int>)
{
std::cout << "1" << std::endl;
}
else
{
std::cout << "2" << std::endl;
}
return Res{};
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
int x;
fun<float>(&x); //输出2
return a.exec();
}
● 引入“假“”函数形参
#include<type_traits>
template<typename Res, typename T>
Res fun(T x, const Res&)
{
if constexpr(std::is_same_v<Res, int>)
{
std::cout << "1" << std::endl;
}
else
{
std::cout << "2" << std::endl;
}
return Res{};
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
int x;
fun(&x, float); //输出2
return a.exec();
}
template<typename T>
int fun(T x, const int&)
{
std::cout << "template<typename T> int fun(T x, const int&)" << std::endl;
return int{};
}
template<typename Res, typename T>
Res fun(T x, const Res&)
{
std::cout << "template<typename Res, typename T> Res fun(T x, const Res&)" << std::endl;
return Res{};
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
int x;
fun(&x, int{});
return a.exec();
}
template<typename T>
int fun(T x, const int&)
{
std::cout << "template<typename T> int fun(T x, const int&)" << std::endl;
return int{};
}
template<typename Res, typename T>
Res fun(T x, const Res&)
{
std::cout << "template<typename Res, typename T> Res fun(T x, const Res&)" << std::endl;
return Res{};
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
int x;
fun(&x, float{});
return a.exec();
}
template<typename Res, typename T>
Res fun(T x)
{
if constexpr(std::is_same_v<Res, int>)
{
std::cout << "1" << std::endl;
}
else
{
std::cout << "2" << std::endl;
}
return Res{};
}
template<typename T>
int fun<int, T>(T x) //不支持函数模板的这种特化，Error: Function template partial specialization is not allowed
{
}
● 通过类模板特化解决
●(C++20) 函数模板的简化形式：使用 auto 定义模板参数类型
#include<iostream>
void fun(auto x)
{
}
int main()
{
int x;
fun(&x);
}
//CPPInsights中的输出
#include<iostream>
void fun(auto x)
{
}
/* First instantiated from: insights.cpp:9 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
void fun<int *>(int * x)
{
}
#endif
int main()
{
int x;
fun(&x);
return 0;
}
#include<iostream>
void fun(auto& x)
{
}
int main()
{
int x;
fun(x);
}
//CPPInsights中的输出
#include<iostream>
void fun(auto& x)
{
}
/* First instantiated from: insights.cpp:9 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
void fun<int>(int & x)
{
}
#endif
int main()
{
int x;
fun(x);
return 0;
}
#include<iostream>
void fun(auto&& x)
{
}
int main()
{
int x;
fun(x);
}
//CPPInsights中的输出
#include<iostream>
void fun(auto&& x)
{
}
/* First instantiated from: insights.cpp:9 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
void fun<int &>(int & x)
{
}
#endif
int main()
{
int x;
fun(x);
return 0;
}
#include<iostream>
void fun(auto&& x)
{
}
int main()
{
int x;
fun(2);
}
//CPPInsights中的输出
#include<iostream>
void fun(auto&& x)
{
}
/* First instantiated from: insights.cpp:9 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
void fun<int>(int && x)
{
}
#endif
int main()
{
int x;
fun(2);
return 0;
}
– 优势：书写简捷
– 劣势：在函数内部需要间接获取参数类型信息
void fun(auto& x)
{
decltype(x) tmp = 3;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
int x;
fun(x); //Error: cannot bind non-const lvalue reference of type 'int&' to an rvalue of type 'int'
return a.exec();
}
参考
深蓝学院：C++基础与深度解析