C++中函数模板和模板函数的区别

Posted 2023-04-25

模板函数可以进行隐式的数据类型转换，中函数模板不会进行自动类型转换。

一、函数模版和同名普通函数在同一个作用域中，会优先调用哪个函数，具体如下：

1.函数模型在进行调用的时候会进行严格的类型匹配，而普通函数在调用的时候，会进行函数参数类型转换（前提是自动类型转换）。

2.调用函数模版，本质是类型参数化，将要严格的按照类型进行匹配，不会进行自动类型转换

3.调用普通函数，可以进行隐式的数据类型转换（前提是可以进行自动类型转换），这是普通函数和模版函数的本质区别。

二、函数模版可以像普通函数被重载

1.C++编译器优先考虑普通函数：这是因为普通函数已经存在了，而模版函数还需要进一步的判断，如果函数模版产生一个更好的匹配，那么优先选择函数模版。

2.可以通过空模版实参列表的语法限制编译器只调用模版函数（也就是在参数名之后加上<>，隐含了自动类型推断！），C++编译器是如何支持模版机制的。

参考技术A 函数模板提供了一类函数的抽象，它提供了任意类型为参数及返回值。函数模板经实例化后生成的具体函数成为模板函数。函数模板代表了一类函数，模板函数表示某以具体函数。 参考技术B 类 实例化生成 实例（对象）
函数模板 实例化生成 模板函数 参考技术C 2.1 函数模板的定义
不管它们的性质如何，所有的函数模板都具有同样的基本格式:
template<参数说明>
函数头
函数体

例如，下面是一个2参数的模板的声明:
template<class T>
T max(T param1 ，T param2)

//此处为函数体


2.根据上面已定义的模板，编译器将可生成下面的模板函数（都是对的，函数模板的目的就是函数重载）:
char * max(char * a， char * b) //模板函数1

return (a>b)？a:b；


int max(int a， int b) //模板函数2

return (a>b)？a:b；


double max(double a， double b) //模板函数2

return (a>b)？a:b；。 参考技术D 2.1 函数模板的定义
不管它们的性质如何，所有的函数模板都具有同样的基本格式：
template<参数说明>
函数头
函数体

例如，下面是一个2参数的模板的声明：
template<class T>
T max(T param1 ，T param2)

//此处为函数体


2.根据上面已定义的模板，编译器将可生成下面的模板函数（都是对的，函数模板的目的就是函数重载）：
char * max(char * a, char * b) //模板函数1

return (a>b)?a:b;


int max(int a, int b) //模板函数2

return (a>b)?a:b;


double max(double a, double b) //模板函数2

return (a>b)?a:b;

等等。。。。。。。。。。。。。本回答被提问者采纳

C++中函数模板怎么用

为什么下面的没法运行啊，怎么改。（ //表示系统报的错误）
#include<iostream>
using namespace std;
template<typename T>; //syntax error : '<end Parse>'
T max(T a,T b,T c)
//missing ';' before ''
if(b>a) a=b;
if(c>a) a=c;
return a;


int main()

int i1=8,i2=5,i3=6,i;
double d1=56.9,d2=90.765,d3=43.1,d;
long g1=67843,g2=-456,g3=78123,g;
i=max(i1,i2,i3); //'i' : undeclared identifier // 'max' : undeclared identifier
d=max(d1,d2,d3); //'d' : undeclared identifier // 'max' : undeclared identifier
g=max(g1,g2,g3); //'g' : undeclared identifier // 'max' : undeclared identifier
cout<<"i_max="<<i<<endl;
cout<<"d_max="<<d<<endl;
cout<<"g_max="<<g<<endl;
return 0;

1.函数模板的声明和模板函数的生成

1.1函数模板的声明
函数模板可以用来创建一个通用的函数，以支持多种不同的形参，避免重载函数的函数体重复设计。它的最大特点是把函数使用的数据类型作为参数。
函数模板的声明形式为：
template<typename 数据类型参数标识符>
<返回类型><函数名>(参数表)

函数体

其中，template是定义模板函数的关键字；template后面的尖括号不能省略；typename（或class)是声明数据类型参数标识符的关键字，用以说明它后面的标识符是数据类型标识符。这样，在以后定义的这个函数中，凡希望根据实参数据类型来确定数据类型的变量，都可以用数据类型参数标识符来说明，从而使这个变量可以适应不同的数据类型。例如：
template<typename T>
T fuc(T x, int y)

T x;
//……

如果主调函数中有以下语句：
double d;
int a;
fuc(d,a);
则系统将用实参d的数据类型double去代替函数模板中的T生成函数：
double fuc(double x,int y)

double x;
//……

函数模板只是声明了一个函数的描述即模板，不是一个可以直接执行的函数，只有根据实际情况用实参的数据类型代替类型参数标识符之后，才能产生真正的函数。
关键字typename也可以使用关键字class，这时数据类型参数标识符就可以使用所有的C++数据类型。
1.2.模板函数的生成
函数模板的数据类型参数标识符实际上是一个类型形参，在使用函数模板时，要将这个形参实例化为确定的数据类型。将类型形参实例化的参数称为模板实参，用模板实参实例化的函数称为模板函数。模板函数的生成就是将函数模板的类型形参实例化的过程。例如：
使用中应注意的几个问题：
⑴ 函数模板允许使用多个类型参数，但在template定义部分的每个形参前必须有关键字typename或class，即：
template<class 数据类型参数标识符1，…，class 数据类型参数标识符n>
<返回类型><函数名>(参数表)

函数体

⑵ 在template语句与函数模板定义语句<返回类型>之间不允许有别的语句。如下面的声明是错误的：
template<class T>
int I;
T min(T x,T y)

函数体

⑶ 模板函数类似于重载函数，但两者有很大区别：函数重载时，每个函数体内可以执行不同的动作，但同一个函数模板实例化后的模板函数都必须执行相同的动作。

2 函数模板的异常处理

函数模板中的模板形参可实例化为各种类型，但当实例化模板形参的各模板实参之间不完全一致时，就可能发生错误，如：
template<typename T>
void min(T &x, T &y)
return (x<y)?x:y;
void func(int i, char j)

min(i, i);
min(j, j);
min(i, j);
min(j, i);

例子中的后两个调用是错误的，出现错误的原因是，在调用时，编译器按最先遇到的实参的类型隐含地生成一个模板函数，并用它对所有模板函数进行一致性检查，例如对语句
min(i, j)；
先遇到的实参i是整型的，编译器就将模板形参解释为整型，此后出现的模板实参j不能解释为整型而产生错误，此时没有隐含的类型转换功能。解决此种异常的方法有两种：
⑴采用强制类型转换，如将语句min(i, j);改写为min(i,int( j));
⑵用非模板函数重载函数模板
方法有两种：
① 借用函数模板的函数体
此时只声明非模板函数的原型，它的函数体借用函数模板的函数体。如改写上面的例子如下：
template<typename T>
void min(T &x, T &y)
return (x<y)?x:y;
int min(int,int);
void func(int i, char j)

min(i, i);
min(j, j);
min(i, j);
min(j, i);

执行该程序就不会出错了，因为重载函数支持数据间的隐式类型转换。
② 重新定义函数体
就像一般的重载函数一样，重新定义一个完整的非模板函数，它所带的参数可以随意。C++中，函数模板与同名的非模板函数重载时，应遵循下列调用原则：
• 寻找一个参数完全匹配的函数，若找到就调用它。若参数完全匹配的函数多于一个，则这个调用是一个错误的调用。
• 寻找一个函数模板，若找到就将其实例化生成一个匹配的模板函数并调用它。
• 若上面两条都失败，则使用函数重载的方法，通过类型转换产生参数匹配，若找到就调用它。
•若上面三条都失败，还没有找都匹配的函数，则这个调用是一个错误的调用。 参考技术A 很不好意思，Java的特性比C++少得多。Java不支持模板。只支持很少的类似于C++模板的语法来实现很有限的泛型编程。

Java对泛型编程的支持也是最近才加进去的，而且支持的很不好。你就不用指望能像C++那样用它了。

Java是一个非常纯粹的OOP语言，它天生就是相对动态的、后期的，编译期处理的信息非常少，这和C++强静态的特性是完全相反的。

Java的绝大部分类型信息都属于RTTI，也就是在运行时动态获取，不像C++是在编译期由编译器推导的，所以Java基本上不可能支持C++那样灵活的模板。

Java的泛型也是，说白了只是个障眼法，用类似C++那样的模板语法来包装了其面向对象动态cast的本质而已。
举例说，java中的Vector<int>，你给里面保存int的时候，每一个int都是先被包装成一个Integer对象然后塞进去，取出来的时候是先取出Object对象，转换成Integer对象，然后再从里面取出int这个整数，绕了很大一个弯子。
虽然从代码上写的和C++差不多都很简洁，但是实际的效率和C++差了n个数量级。这点上实在是比较恶心，C#都做得比它好，C#至少对于值类型还是会实例化代码的。

Java天生就是一个鼓励动态化、运行期化、OOP化的一个语言，所以它不适合使用C++中那些泛型编程的范式来设计程序。你如果能够忍受Java的装箱拆箱的巨大效率损失，你可以用OOP的方式来实现那种同一个函数服务多种类型的想法，但是的确很低效。 参考技术B template<typename T>; 去掉分号

i=max(i1,i2,i3); 改成i=max<int>(i1, i2, i3)
d=max(d1,d2,d3); 改成max<double>
g=max(g1,g2,g3); 改成max<long>

看一下这个链接就明白了：
http://www.cplusplus.com/doc/tutorial/templates/ 参考技术C template<typename T>后面不能有;本回答被提问者采纳