C++核心编程之函数模板

1 模板的概念

        模板是C++中一种强大的工具，它允许我们编写通用的代码，从而提高代码的复用性。模板可以理解为一种通用的模具，通过它我们可以生成特定类型的函数或类。

模板的特点：

模板不能直接使用，它只是一个框架，需要根据具体类型进行实例化。

模板的通用性并不是万能的，某些特定类型可能需要特殊处理。

2 函数模板

        C++中的泛型编程思想主要通过模板来实现。C++提供了两种模板机制：函数模板和类模板。本节主要介绍函数模板的使用。

2.1 函数模板语法

        函数模板的作用是建立一个通用函数，其返回值类型和形参类型可以不具体指定，而是用一个虚拟的类型来代表。

语法：

template<typename T> 函数声明或定义

解释：

template：声明创建模板。

typename：表示其后面的符号是一种数据类型，可以用class代替。

T：通用的数据类型，名称可以替换，通常为大写字母。

代码案例如下:

#include<iostream> using namespace std; // 两个整型交换函数 void swapInt(int& a, int& b) { int temp = a; a = b; b = temp; } // 交换两个浮点型函数 void swapDouble(double& a, double& b) { double temp = a; a = b; b = temp; } // 函数模板 template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型 void Swap(T& a, T& b) { T temp = a; a = b; b = temp; } void test01() { int a = 1; int b = 2; //swapInt(a, b); //利用函数模板交换 //两种方式使用函数模板 //1、自动类型推导 //Swap(a, b); //2、显示指定类型 Swap<int>(a, b); cout << "a = " << a << endl; cout << "b = " << b << endl; double c = 1.1; double d = 2.2; swapDouble(c, d); cout << "c = " << c << endl; cout << "d = " << d << endl; } int main() { test01(); system("pause"); return 0; }

总结：

函数模板利用关键字template。

使用函数模板有两种方式：自动类型推导和显示指定类型。

模板的目的是为了提高复用性，将类型参数化。

2.2 函数模板注意事项

注意事项：

自动类型推导必须推导出一致的数据类型T，才可以使用。

模板必须要确定出T的数据类型，才可以使用。

代码案例如下:

#include<iostream> using namespace std; // 函数模板注意事项 // 函数模板 template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型 typename 可以替换成class void Swap(T& a, T& b) { T temp = a; a = b; b = temp; } // 1、自动类型推导，必须推到出一致的数据类型T，才可以使用 void test01() { int a = 1; int b = 2; // char c = 'c'; Swap<int>(a, b); // 正确 // Swap(a, c); // 错误 推导不出一致的T类型 cout << "a = " << a << endl; cout << "b = " << b << endl; } // 2、模板必须要确定出T的数据类型，才可以使用 template<class T> void func() { cout<<"func 调用"<<endl; } void test02() { func<int>(); } int main() { test01(); test02(); system("pause"); return 0; }

总结：

使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型。

2.3 函数模板案例

案例描述：

利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序。

排序规则从大到小，排序算法为选择排序。

分别利用char数组和int数组进行测试。

代码案例如下:

#include<iostream> using namespace std; // 实现通用 对数组进行排序的函数 // 规则 从大到小 // 算法 选择排序 // 测试 int和char // 交换的函数模板 template<typename T> void Swap(T &a, T &b) { T temp = a; a = b; b = temp; } // 利用选择排序 template<typename T> void Sort(T arr[], int len) { for(int i=0;i<len;i++) { int max = i; // 认定最大值的下标 for(int j=i+1; j<len; j++) { if(arr[max]<arr[j]) { // 交换max和i的元素 Swap(arr[max], arr[j]); } } } } // 提供打印数组模板 template<class T> void printArr(T arr[], int len) { for(int i=0; i<len; i++) { cout<<arr[i]<<" "; } cout<<endl; } void test01() { char charArr[] = "adiuec"; int len = sizeof(charArr)/sizeof(char); Sort(charArr, len); cout<<"排序后的char数组如下："<<endl; printArr(charArr, len); } void test02() { int intArr[] = {3,8,4,6,7,9,2,0,1,5}; int len = sizeof(intArr)/sizeof(int); Sort(intArr, len); cout<<"排序后的int数组如下："<<endl; printArr(intArr, len); } int main() { test01(); test02(); system("pause"); return 0; }

总结： 模板可以提高代码复用。

2.4 普通函数与函数模板的区别

普通函数调用时可以发生自动类型转换（隐式类型转换）。

函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换。

如果利用显示指定类型的方式，可以发生隐式类型转换。

代码案例如下:

#include<iostream> using namespace std; // 普通函数与函数模板的区别 // 1.普通函数调用 可以发生隐式类型转换 // 2.函数模板 用自动类型推导，不可以发生隐式类型转换 // 3.函数模板 用显示指定类型，可以发送隐式类型转换 // 普通函数 int Add01(int a, int b) { return a+b; } // 函数模板 template<class T> T Add02(T a, T b) { return a+b; } void test01() { int a = 89; int b = 11; char c = 'c'; // a 97 c 99 cout<<Add01(a,c)<<endl; // 自动类型推导 不可以发生隐式类型转换 // cout<<Add02(a,c)<<endl; // 显示指定类型 可以发生隐式类型转换 cout<< Add02<int>(a,c)<<endl; } int main() { test01(); system("pause"); return 0; }

总结： 建议使用显示指定类型的方式调用函数模板，因为可以自己确定通用类型T。

2.5 普通函数与函数模板的调用规则

调用规则如下：

如果函数模板和普通函数都可以实现，优先调用普通函数。

可以通过空模板参数列表来强制调用函数模板。

函数模板也可以发生重载。

如果函数模板可以产生更好的匹配，优先调用函数模板。

代码案例如下:

#include<iostream> using namespace std; // 普通函数与函数模板的调用规则 // 1、如果函数模板和普通函数都可以实现，优先调用普通函数 // 2、可以通过空模板参数列表 强制调用 函数模板 // 3、函数模板可以发生重载 // 4、如果函数模板可以产生更好的匹配，优先调用函数模板 void myPrint(int a, int b) { cout<<"普通函数的调用"<<endl; } template<class T> void myPrint(T a, T b) { cout<<"函数模板的调用"<<endl; } // 函数模板可以发生重载 template<class T> void myPrint(T a, T b, T c) { cout<<"函数模板重载的调用"<<endl; } void test01() { int a = 88; int b = 12; // 如果函数模板和普通函数都可以实现，优先调用普通函数 myPrint(a, b); // 通过空模板参数列表 强制调用 函数模板 myPrint<>(a, b); myPrint<>(a, b, 1); // 如果函数模板可以产生更好的匹配，优先调用函数模板 char c1 = 'a'; char c2 = 'b'; myPrint(c1, c2); } int main() { test01(); system("pause"); return 0; }

总结： 既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性。

2.6 模板的局限性

局限性：

模板的通用性并不是万能的。

代码案例如下:

       C++提供了模板的重载，可以为这些特定的类型提供具体化的模板。

#include<iostream> using namespace std; #include<string> // 模板的局限性 // 模板的通用性并不是万能的, 有些特定数据类型，需要用具体化方式做特殊实现 class Person { public: Person(string name, int age) { this->m_Name = name; this->m_Age = age; } // // 运算符重载 // bool operator==(Person &p) // { // if(this->m_Name == p.m_Name && this->m_Age == p.m_Age) // { // return true; // } // return false; // } // 姓名 string m_Name; // 年龄 int m_Age; }; // 对比两个数据是否相等 template<class T> bool Compare(T &a, T &b) { if(a==b) { return true; } else { return false; } } // 利用具体化Person的版本实现代码，具体化优先调用 template<> bool Compare(Person &p1, Person &p2) { if(p1.m_Name==p2.m_Name && p1.m_Age==p2.m_Age) { return true; } return false; } void test01() { int a = 10; int b = 25; bool ret = Compare(a, b); if(ret) { cout<<"两个数字相等"<<endl; } else { cout<<"两个数字不相等"<<endl; } } void test02() { Person p1("约翰", 24); Person p2("约翰", 25); bool ret = Compare(p1, p2); if(ret) { cout<<"p1==p2"<<endl; } else { cout<<"p1!=p2"<<endl; } } int main() { test01(); test02(); system("pause"); return 0; }

总结：

利用具体化的模板，可以解决自定义类型的通用化问题。

学习模板并不是为了写模板，而是在STL中能够运用系统提供的模板。

通过本文的学习，你应该对C++中的函数模板有了更深入的理解。模板是C++中非常强大的工具，熟练掌握它可以大大提高代码的复用性和灵活性。