函数模板定义格式
模板函数定义格式如下:
template <typename T>
返回类型 函数名(参数列表) {
// 函数体
}
其中,template<typename T>
是模板声明,用于定义模板参数 T
。可以使用不同的关键字代替 typename
,例如 class
。
返回类型
是函数返回的数据类型,可以是基本数据类型、自定义数据类型或者 void
。
函数名
是函数的名称,可以根据需要命名。
参数列表
是函数的参数,可以是零个或多个参数,参数之间用逗号分隔。每个参数都可以有自己的数据类型和名称。
函数体
是函数的具体实现。在模板函数中,可以使用模板参数 T
来代表不同的数据类型。
例如,定义一个模板函数来计算数组的平均值:
template <typename T>
T average(T arr[], int size) {
T sum = 0;
for (int i = 0; i < size; i++) {
sum += arr[i];
}
return sum / size;
}
在调用模板函数时,需要指定模板参数的具体类型。例如,调用模板函数计算整型数组的平均值:
int arr[] = {1, 2, 3, 4, 5};
int size = sizeof(arr) / sizeof(arr[0]);
int avg = average<int>(arr, size);
实例化函数模板
我们先定义一个函数模板
template <typename T>
int compare(const T& vl, const T& v2)
{
if (v1 < v2) return -1;
if (v2 < v1) return 1;
return 0;
}
当我们调用一个函数模板时,编译器(通常)用函数实参来为我们推断模板实参,即,当我们调用compare时,编译器使用实参的类型来确定绑定到模板参数T的类型。
例如,在下面的调用中:
cout << compare(1, 0) << endl; // T为int
实参类型是int。编译器会推断出模板实参为int,并将它绑定到模板参数T。
编译器用推断出的模板参数来为我们实例化一个特定版本的函数。
当编译器实例化一个模板时,它使用实际的模板实参代替对应的模板参数来创建出模板的一个新“实例”。
例如,给定下面的调用:
// 实例化出 int compare(const int&, const int&)
cout << compare(1, 0) << endl;// T为int
//实例化出 int compare (const vector<int>&, const vector<int>&)
vector<int>vec1{1, 2,3},vec2{4, 5, 6};
cout << compare(vec1, vec2) << endl; // T为vector<int>
编译器会实例化出两个不同版本的 compare。
对于第一个调用,编译器会编写并编译一个compare版本,其中T被替换为int:
int compare (const int &vl, const int &v2)
{
if (v1 < v2) return -1;
if (v2 < v1) return 1;
return 0;
}
对于第二个调用,编译器会生成另一个compare版本,其中T被替换为vector<int>。
这些编译器生成的版本通常被称为模板的实例(instantiation)。
我们再看一个例子
在编译器编译阶段,对于模板函数的使用,编译器需要根据传入的实参类型来推演生成对应类型的函数以供 调用。
比如:当用double类型使用函数模板时,编译器通过对实参类型的推演,将T确定为double类型,然 后产生一份专门处理double类型的代码,对于字符类型也是如此。
模板类型参数
我们的compare函数有一个模板类型参数。
一般来说,我们可以将类型参数看作类型说明符,就像内置类型或类类型说明符一样使用。
特别是,类型参数可以用来指定返回类型或函数的参数类型,以及在函数体内用于变量声明或类型转换:
//正确:返回类型和参数类型相同
template <typename T> T foo (T* p)
{
T tmp = *p; // tmp的类型将是指针p指向的类型
//...
return tmp;
}
类型参数前必须使用关键字class或typename:
// 错误:U之前必须加上cIasa 或typename
template <typename T,U>
T calc(const T&, const U&);
在模板参数列表中,这两个关键字的含义相同,可以互换使用。一个模板参数列表中可以同时使用这两个关键字:
// 正确:在模板参数列表中,typename和class 没有什么不同
template <typename T, class U> calc (const T&, const U&);
看起来用关键字typename来指定模板类型参数比用class更为直观。
毕竟,我们可以用内置(非类)类型作为模板类型实参。
而且,typename更清楚地指出随后的名字是一个类型名。但是,typename是在模板已经广泛使用之后才引入C++语言的,某些程序员仍然只用class。
非类型模板参数
除了定义类型参数,还可以在模板中定义非类型参数。
一个非类型参数表示一个值而非一个类型。
我们通过一个特定的类型名而非关键字class或typename 来指定非类型参数。
当一个模板被实例化时,非类型参数被一个用户提供的或编译器推断出的值所代替。这些值必须是常量表达式,从而允许编译器在编译时实例化模板。
例如,我们可以编写一个compare版本处理字符串字面常量。这种字面常量是constchar的数组。由于不能拷贝一个数组,所以我们将自己的参数定义为数组的引用。
由于我们希望能比较不同长度的字符串字面常量,因此为模板定义了两个非类型的参数。第一个模板参数表示第一个数组的长度,第二个参数表示第二个数组的长度:
template<unsigned N, unsigned M>
int compare(const char(&pl)[N], const char(&p2)[M])
{
return strcmp(pl, p2);
}
当我们调用这个版本的compare时:
compare("hi", "mom");
编译器会使用字面常量的大小来代替N和M,从而实例化模板。记住,编译器会在一个字符串字面常量的末尾插入一个空字符作为终结符,因此编译器会实例化出如下版本:
int compare (const char (&pl)[3], const char (&p2)[4])
- 一个非类型参数可以是一个整型,或者是一个指向对象或函数类型的指针或(左值)引用。
- 绑定到非类型整型参数的实参必须是一个常量表达式。
- 绑定到指针或引用非类型参数的实参必须具有静态的生存期。
- 我们不能用一个普通(非static)局部变量或动态对象作为指针或引用非类型模板参数的实参。
- 指针参数也可以用nullptr或一个值为0的常量表达式来实例化。
- 在模板定义内,模板非类型参数是一个常量值。在需要常量表达式的地方,可以使非类型参数,例如数组大小。
非类型模板参数的模板实参必须是常量表达式
inline和constexpr的函数模板
函数模板可以声明为inline或constexpr的,如同非模板函数一样。
inline或constexpr说明符放在模板参数列表之后,返回类型之前;
//正确;inline说明符跟在模板参数列表之后
template <typename T> inline T min(const T&, const T&);
//错误:inline说明符的位置不正确
inline template <typename T> T min(const T&, const T&);
编写类型无关的代码
我们最初的compare函数虽然简单,但它说明了编写泛型代码的两个重要原则:
- 模板中的函数参数是const的引用。
- 函数体中的条件判断仅使用<比较运算。
通过将函数参数设定为const的引用,我们保证了函数可以用于不能拷贝的类型。
大多数类型,包括内置类型和我们已经用过的标准库类型(除unique_ptr和IO类型之外),都是允许拷贝的。
但是,不允许拷贝的类类型也是存在的。
通过将参数设定为const的引用,保证了这些类型可以用我们的compare函数来处理。
而且,如果 compare用于处理大对象,这种设计策略还能使函数运行得更快。
你可能认为既使用<运算符又使用>运算符来进行比较操作会更为自然:
//期望的比较操作
if (v1 < v2) return -1;
if (v1 > v2) return 1;
return 0;
但是,如果编写代码时只使用<运算符,我们就降低了 compare 函数对要处理的类型的要求。
这些类型必须支持<,但不必同时支持>。
实际上,如果我们真的关心类型无关和可移植性,可能需要用less来定义我们的函数:
// 即使用于指针也正确的compare版本;
template <typename T> int compare(const T 6vl, const T &v2)
{
if (less<T>()(v1, v2)) return -1;
if (less<T>()(v2, v1)) return 1;
return 0;
}
原始版本存在的问题是,如果用户调用它比较两个指针,且两个指针未指向相同的数组,则代码的行为是未定义的(据查阅资料,less<T>的默认实现用的就是<,所以这其实并未起到让这种比较有一个良好定义的作用)。
模板程序应该尽量减少对实参类型的要求。
模板编译
当编译器遇到一个模板定义时,它并不生成代码。
只有当我们实例化出模板的一个特定版本时,编译器才会生成代码。当我们使用(而不是定义)模板时,编译器才生成代码,
这一特性影响了我们如何组织代码以及错误何时被检测到,
通常,当我们调用一个函数时,编译器只需要掌握函数的声明。类似的,当我们使用一个类类型的对象时,类定义必须是可用的,但成员函数的定义不必已经出现。因此,我们将类定义和函数声明放在头文件中,而普通函数和类的成员函数的定义放在源文件中
模板则不同:为了生成一个实例化版本,编译器需要掌握函数模板或类模板成员函数的定义。因此,与非模板代码不同,模板的头文件通常既包括声明也包括定义
函数模板和类模板成员函数的定义通常放在头文件中。
关键概念:模板和头文件
模板包含两种名字:
- 那些不依赖于模板参数的名字
- 那些依赖于模板参数的名字
当使用模板时,所有不依赖于模板参数的名字都必须是可见的,这是由模板的提供者来保证的。而且,模板的提供者必须保证,当模板被实例化时,模板的定义,包括类模板的成员的定义,也必须是可见的。
用来实例化模板的所有函数、类型以及与类型关联的运算符的声明都必须是可见的,这是由模板的用户来保证的。
通过组织良好的程序结构,恰当使用头文件,这些要求都很容易满足。模板的设计者应该提供一个头文件,包含模板定义以及在类模板或成员定义中用到的所有名字的声明。模板的用户必须包含模板的头文件,以及用来实例化模板的任何类型的头文件。
大多数编译错误在实例化期间报告
模板直到实例化时才会生成代码,这一特性影响了我们何时才会获知模板内代码的编译错误。通常,编译器会在三个阶段报告错误。
- 第一个阶段是编译模板本身时。在这个阶段,编译器通常不会发现很多错误。编译器可以检查语法错误,例如忘记分号或者变量名拼错等,但也就这么多了。
- 第二个阶段是编译器遇到模板使用时。在此阶段,编译器仍然没有很多可检查的。对于函数模板调用,编译器通常会检查实参数目是否正确。它还能检查参数类型是否匹配。对于类模板,编译器可以检查用户是否提供了正确数目的模板实参,但也仅限于此了。
- 第三个阶段是模板实例化时,只有这个阶段才能发现类型相关的错误。 依赖于编译器如何管理实例化,这类错误可能在链接时才报告。
当我们编写模板时,代码不能是针对特定类型的,但模板代码通常对其所使用的类型有一些假设。
例如,我们最初的compare函数中的代码就假定实参类型定义了<运算符。
if (v1 <v2) return -1;// 要求类型T的对象支持<操作
if (v2 <v1) return 1;//要求类型T的对象支持<操作
return 0; //返回int;不依赖于
当编译器处理此模板时,它不能验证 if 语句中的条件是否合法。
如果传递给 compare的实参定义了<运算符,则代码就是正确的,否则就是错误的。例如,
Sales_data datal, data2;
cout << compare(datal,data2) << endl;// 错误:Sales_data未定义<
此调用实例化了 compare 的一个版本,将T替换为 Sales_data。
if 条件试图对Sales_data 对象使用<运算符,但Sales data并未定义此运算符。此实例化生成了一个无法编译通过的函数版本。但是,这样的错误直至编译器在类型Sales_data 上实例化compare时才会被发现。
保证传递给模板的实参支持模板所要求的操作,以及这些操作在模板中能正确WARNING 工作,是调用者的责任。