1 #include <iostream> 2 #include <string> 3 #include <vector> 4 using namespace std; 5 6 template <typename T> 7 T max(T a, T b) 8 { 9 return a > b ? a : b; 10 } 11 12 13 14 int main(int argc, const char *argv[]) 15 { 16 int i = 42; 17 cout << ::max(7, i) << endl; 18 19 double f1 = 3.4; 20 double f2 = -6.7; 21 cout << ::max(f1, f2) << endl; 22 23 string s1 = "hello"; 24 string s2 = "world"; 25 cout << ::max(s1, s2) << endl; 26 27 28 return 0; 29 } 30 //次模板函数，是值拷贝型， 输入和返回值都是值拷贝，开销巨大， 如果我们 输入和返回值都是类类型的话， 对资源的消耗是巨大的。 31 所以一般用下面这种模板
#include <iostream> #include <string> #include <vector> using namespace std; template <typename T> const T &max(const T &a,const T &b) { return a > b ? a : b; } int main(int argc, const char *argv[]) { int i = 42; cout << ::max(7, i) << endl; double f1 = 3.4; double f2 = -6.7; cout << ::max(f1, f2) << endl; string s1 = "hello"; string s2 = "world"; cout << ::max(s1, s2) << endl; return 0; }
上面这种模板，会节约很多。
下面介绍一种有坑的情况
1 #include <iostream> 2 #include <string> 3 #include <vector> 4 using namespace std; 5 6 template <typename T> 7 const T &max(const T &a, const T &b) 8 { 9 return a > b ? a : b; 10 } 11 12 13 14 int main(int argc, const char *argv[]) 15 { 16 //编译错误 17 cout << ::max(4, 4.7) << endl; 18 return 0; 19 }
我们输入为 4-int 4.7-double ， 编译器无法找到一个模板去匹配， 编译错误。
因为我们模板是两个参数都是T类型的， 而不是一个是T1，另一个是T2；
好吧，我们尝试一下两个参数类型是不同的模板
1 #include <iostream> 2 #include <string> 3 #include <vector> 4 using namespace std; 5 6 template <typename T1, typename T2> 7 const T1 &max(const T1 &a, const T2 &b) 8 { 9 return a > b ? a : b; 10 } 11 12 13 14 int main(int argc, const char *argv[]) 15 { 16 cout << ::max(3, 4.5) << endl; 17 // int double 18 // const int &max(const int &, const double &); 19 // 因为T1与T2类型不同，所以进行强制类型转换 20 // 产生了一个中间临时变量 21 // 所以最后的返回值，引用了一个临时变量 22 23 return 0; 24 }
上面是一个错误了例子， 编译不会通过， 错误十分隐晦， 我们看到 参数1是 T1， 参数2 是T2，
我们输入时 参数a是3 --int 参数b是4.5--double，那么我们告诉编译器去生成一个int &max（const int &， const double &）的函数，
返回值和 参数一都是T1==int， 显然 4.5 是比3大的， 所以返回的是4.5，但是我们要求返回值是int型， 显然也不匹配， 所以编译器会进行，强制转换 生成一个tmp = （int）4.5；
return tmp的引用。 tmp是临时变量， 该函数调用结束后栈空间被释放， 返回临时变量的引用是没有意义的。
所以导致编译错误
下面看一下模板的重载
例子代码：
1 #include <iostream> 2 #include <string> 3 #include <vector> 4 5 using namespace std; 6 7 8 9 const int &max(const int &a, const int &b) 10 { 11 return a > b ? a : b ; 12 } 13 template <typename T> 14 15 const T &max(const T &a, const T &b) 16 { 17 return a > b ? a: b ; 18 } 19 20 template <typename T> 21 const T &max(const T &a, const T &b, const T &c) 22 { 23 return ::max(::max(a, b), c) ; 24 } 25 26 27 28 29 int main(int argc, const char *argv[]) 30 { 31 ::max(7, 42, 68) ; //调用第三个 32 ::max(7.0, 43.5) ; //调用第二个 33 ::max('a', 'b') ; //调用第二个 34 ::max(7, 42) ; //调用第一个，其实第二个也可以，但是取最匹配的 35 ::max<>(7, 42) ; //指定从模板2 进行匹配， 根据模板生成一个 int &max(const int &, const int &) 36 cout << ::max<double>(7,42) <<endl; // 调用2 进行强制转换。 37 cout << ::max('a', 42.7) << endl; //调用1， 进行强制转换 38 return 0; 39 }
总之不需要死记调用的规则， 掌握一个原则， 编译器总是选择调用最合适的那个函数。
1 #include <iostream> 2 #include <string> 3 #include <vector> 4 using namespace std; 5 6 7 8 template <typename T> 9 const T &max(const T &a, const T &b) 10 { 11 return a > b ? a : b ; 12 } 13 14 template <typename T> 15 const T *max(const T *a, const T *b) 16 { 17 return *a > *b ? a : b ; 18 } 19 20 const char *max(const char *a, const char *b) 21 { 22 return ::strcmp(a, b) > 0 ? a : b ; 23 } 24 25 26 27 int main(int argc, const char *argv[]) 28 { 29 int a = 7 ; 30 int b = 42 ; 31 ::max(a, b); //调用第一个,上面3个模板 最匹配的显然是第一个。 32 33 string s = "hey" ; 34 strubg t = "world" ; 35 ::max(s, t) ; //调用第一个 最匹配的显然还是第一个 36 37 int *p1 = &7 ; 38 int *p2 = &8 ; 39 ::max(p1, p2) ; //调用第二个， 当参数是指针时， 优先调用指针为参数的模板，最匹配为第二个 40 41 const char *s1 = "fucker" ; 42 const char *s2 = "asshole" ; 43 ::max(s1, s2) ; //调用第3个。 2和3都是 指针为参数的模板， 但是第三个更精确。所以调用第三个 44 return 0; 45 }
根据上面几个例子， 我们可以总结出几个规律，这个规律是编译器 合成模板函数， 调用的规则， 这是C++最晦涩的部分之一， 其编译器实现是十分复杂的，集结的前人无数心血
a) 当条件相同时，优先选择非模板函数。例如::max(7, 42);
b) 在强制类型转化，与实例化模板可行之间，优先选择实例化模板。::max(7.0, 43.5); ::max('a', 'b');
c) 实例化版本不可行，则去尝试普通函数的转化，例如::max('a', 42.7);
d) 参数是指针时，优先选择指针版本。
e) 总之，尽可能采用最匹配的版本。
下面介绍一个陷阱
1 #include <iostream> 2 #include <string> 3 #include <vector> 4 #include <string.h> 5 using namespace std; 6 7 8 template <typename T> 9 const T &max(const T &a, const T &b) 10 { 11 return a > b ? a : b ; 12 } 13 const char *max(const char * a, const char *b) 14 { 15 return ::strcmp(a, b) > 0 ? a : b ; 16 } 17 18 template <typename T> 19 const T &max(const T &a, const T &b, const T &c) //三参数版本的模板函数， 要根据情况来调用 上面两个 20 { 21 return ::max(::max(a, b), c) ; //调用1 或者 2 22 } 23 24 int main(int argc, const char *argv[]) 25 { 26 ::max(7 ,42, 68) ; //ok --> 当三调用 1 时， 1返回的也是引用， 3 再接收这个引用，在返回给主函数 27 28 const char *p1 = "hello" ; 29 const char *p2 = "world" ; 30 const char *p3 = "fuck" ; 31 32 ::max(p1, p2 , p3) //--》这个3 要调用2， 而返回的是一个指针的拷贝（指针拷贝就是， 新创建一个指针， 指向旧指针的指向） 33 //像这个 p1 --> a <-- p2 ; p1 是== p2的， 解引用后内容一样，但是指针是不同的。 34 return 0; //当 3 再把 2 返回的一个临时指针（局部变量） 当引用 传出， 就出现了编译错误 35 }
上述得出结论：
在模板函数重载中，不要混合使用传值和传引用。尽可能使用传引用。
会导致产生临时变量， 以至于外层的函数当做引用 传出。 解决上面BUG的方法就是， 把函数2 的返回值和输入参数加上引用 。
1 #include <iostream> 2 #include <string> 3 #include <vector> 4 #include <string.h> 5 using namespace std; 6 7 //传引用 8 template <typename T> 9 const T &max(const T &a, const T &b) 10 { 11 return a > b ? a : b; 12 } 13 14 const char *&max(const char *&a, const char *&b) 15 { 16 return ::strcmp(a, b) > 0 ? a : b; 17 } 18 19 //求3个任意类型的最大值 20 //传引用 21 template <typename T> 22 const T &max(const T &a, const T &b, const T &c) 23 { 24 return ::max(::max(a, b), c); 25 //::max(::max(s1, s2), s3); //返回的是一个临时的变量 26 //这里将临时变量的引用返回出去，可能导致错误 27 //const char *temp = ::max(::max(s1, s2), s3); 28 // 29 } 30 31 32 int main(int argc, const char *argv[]) 33 { 34 ::max(7, 42, 68); 35 36 const char *s1 = "fegfwe"; 37 const char *s2 = "Fwtfgt"; 38 const char *s3 = "geryhgr5"; 39 ::max(s1, s2, s3); 40 41 42 return 0; 43 }
OK , BUG 解决了。
思考：
1.传值和传引用对于参数来说，本质区别在于是否产生了局部变量。