函数模板的工作机制 函数模板的本质 多参数函数模板 函数重载与函数模板
函数模板的工作机制
问题:函数模板的工作原理是怎么样的?如何区分类型的?跟宏定义的方式有区别吗?
1. 编译器从函数模板通过具体类型产生不同的函数
根据自动推导类型的方式,我们就可以知道,函数模板实际是根据传入的实参来判断类型的。
2. 编译器会对函数模板进行两次编译
3. 第一次编译:对模板代码本身进行编译
4. 第二次编译:对参数替换后的代码进行编译
这个机制实际就是为了解决宏定义无法对类型检查的缺陷。第一次编译检查模板函数是否存在语法错误。 第二次编译是在我们调用这个函数的时候,为了得到相对应类型的函数,会再次进行编译。
根据编译器对函数模板的二次编译我们可以知道,函数模板并不是一个实际存在的一个函数,而是产生实际函数的模子。当我们使用参数进行调用,编译器第二次编译后才会产生一个真正的函数。
函数模板的本质
问题:我们如何证明函数模板第二次编译才产生对应类型的函数呢?
示例代码:函数模板的本质
#include #include using namespace std; template < typename t > void swap(t& a, t& b) { t c = a; a = b; b = c; } typedef void(funci)(int&, int&); typedef void(funcd)(double&, double&); int main() { funci* pi = swap; // 编译器自动推导 t 为 int funcd* pd = swap; // 编译器自动推导 t 为 double cout << "pi = " << reinterpret_cast(pi) << endl; cout << "pd = " << reinterpret_cast(pd) << endl; return 0; }
输出结果:
pi = 0x41bbb8
pd = 0x41bb84
分析:
1. 我们可以发现,函数指针指向同一个函数,但是输出地址却不相同。
这就说明了实际上编译器为我们产生了两个参数类型不同的函数。
而产生实际函数是在我们指定特定参数类型时才产生的,也就是第二次编译。不然怎么不产生别的类型的函数呢。
多参数函数模板
问题:在我们编写函数时,不可能说函数参数都是相同的,而我们上面所讲的都是函数相同的情况。那么函数参数各不相同时,有返回值时,应该怎么定义函数模板呢?
示例代码:多参数函数模板
#include #include using namespace std; template < typename t1, typename t2, typename t3 > t1 add(t2 a, t3 b) { return static_cast(a + b); } int main() { int r1 = add(3, 4); //error,cannot auto type inference // t1 = double, t2 = int, t3 = double double r2 = add(5, 0.8); // t1 = int, t2 = float, t3 = float float r3 = add(0.5, 0.8); cout << "r2 = " << r2 << endl; cout << "r3 = " << r3 << endl; return 0; }
输出结果:
r2 = 5.8
r3 = 1
分析:
1. int r1 = add(3, 4); 编译器报错。为什么呢?
就是因为编译器无法自动推导返回值类型。
2. double r2 = add
函数重载与函数模板
实际上,函数模板的实现跟函数重载有点相似。但是函数模板不需要编写大量重复的函数,而是编译器自动帮我们生成了相对应的函数。
那儿,当有一个函数重载了 模板函数,那么编译器会产生什么呀的现象呢?
示例代码:重载函数模板
#include #include using namespace std; template < typename t > t max(t a, t b) { cout << "t max(t a, t b) = "; return a > b ? a : b; } int max(int a, int b) { cout << "int max(int a, int b) = " ; return a > b ? a : b; } template < typename t> t max(t a, t b, t c) { cout << "t max(t a, t b, t c) = "; return max(max(a, b), c); } int main() { int a = 1; int b = 2; cout << max(a, b) << endl; // 普通函数 max(int, int) cout << max<>(a, b) << endl; // 函数模板 max(int, int) cout << max(3.0, 4.0) << endl; cout << max(3, 4, 5) << endl;// 函数模板 max(int, int, int) cout << max(5.0, 6.0, 7.0) << endl; cout << max('a', 100) << endl;// 普通函数 max(int, int) return 0; }
输出结果:
int max(int a, int b) = 2
t max(t a, t b) = 2
t max(t a, t b) = 4
t max(t a, t b, t c) = int max(int a, int b) = int max(int a, int b) = 5
t max(t a, t b, t c) = t max(t a, t b) = t max(t a, t b) = 7
int max(int a, int b) = 100
分析:
1. cout << max(a, b) << endl; 编译器并没有选择函数模板,而是优先考虑了普通函数。
2. cout << max<>(a, b) << endl; 可以通过空模板实参列表限定编译器只匹配模板
3. cout << max(3, 4, 5) << endl; 和 cout << max(5.0, 6.0, 7.0) << endl; 产生一个更好的匹配时,会自动选择模板或者普通函数。
函数重载与函数模板并不冲突。当面对编译器面对选择时:
1. 当参数类型符合普通函数时,优先选择普通函数。
2. 如果函数模板可以产生一个更好的匹配,那么选择模板。
这种选择也符合我们人类的观点:有更好更方便的,优先选择。
本文来自网络收集,不代表计算机技术网立场,如涉及侵权请联系管理员删除。
ctvol管理联系方式QQ:251552304
本文章地址:https://www.ctvol.com/c-cdevelopment/607495.html