C++函数模板

目录

模板的概念

函数模板

函数模板语法

函数模板注意事项

函数模板案例 —— 数组排序

普通函数和模板函数的区别

普通函数和函数模板调用规则

模板的局限性

模板的概念

模板就是建立通用模具，提高复用性

例如 ppt 模板

模板特点

• 模板不可以直接使用，只是一个框架
• 模板的通用性不是万能的

函数模板

C++另一种编程思想称为 泛式编程 ，主要利用技术就是模板

-

C++提供两种模板机制 函数模板 和 类模板

函数模板语法

函数模板的作用：

建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个 虚拟的类型 代替。

-

语法：

template
//函数声明或定义

-

解释：

template  ---  声明创建模板

-

typename  ---  表面其后的符号是一种数据类型，也可以用 class 代替（可以用来区分函数模板和类模板）

-

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

测试代码：

#include
using namespace std;

template
void mySwap(T& a, T& b)
{
    T temp = a;
    a = b;
    b = temp;
}

int main()
{
    int a = 10;
    int b = 20;
    cout << "交换前" << endl;
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    // 两种方式使用函数模板
    
    // 1、自动类型推导
    mySwap(a, b);
    cout << "交换后" << endl;
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    // 2、显示指定类型
    mySwap(a, b);
    cout << "交换后" << endl;
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    system("pause");
    return 0;
}

运行结果：

函数模板注意事项

注意事项：

• 自动类型推导，必须推导出一致的数据类型 T ，才可以使用
• 模板必须要确认出 T 的数据类型，才可以使用

注意事项①测试：

 编译器只能将 T 确定为一个类型，推导不出一致类型就会出错

注意事项②测试：

调用无参函数模板 

去掉模板声明，可以正常调用普通函数 

 显示指定类型

 模板函数没有参数时，需要用显示指定类型使用函数模板，模板必须要有确定的数据类型才可以使用

函数模板案例 —— 数组排序

案例描述：

• 函数模板封装一个排序函数，可以对不同数据类型数组进行排序
• 排序规则从大到小，排序算法为选择排序
• 分别使用 char数组 和 int数组 进行测试

字符数组测试代码：

#include
using namespace std;

// 交换函数模板
template
void mySwap(T& a, T& b){
    T temp = a;
    a = b;
    b = temp;
}

// 排序函数模板
template
void mySort(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 = j; // 更新最大值下标
            }
        }
        if (max != i){
            // 交换 max 和 i 小标的元素
            mySwap(arr[max], arr[i]);
        }
    }
}

// 输出函数模板
template
void myPrint(T& arr){
    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++){
        cout << arr[i] << " ";
    }
    cout << endl;
}

void test(){
    char arr[5] = { 'a', 'b', 'c', 'd', 'e'};
    int len = sizeof(arr) / sizeof(arr[0]);
    mySort(arr, len);
    myPrint(arr);   
}

int main(){
    test();
    system("pause");
    return 0;
}

运行结果：

整形数组测试代码：

#include
using namespace std;

// 交换函数模板
template
void mySwap(T& a, T& b){
    T temp = a;
    a = b;
    b = temp;
}

// 排序函数模板
template
void mySort(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 = j; // 更新最大值下标
            }
        }
        if (max != i){
            // 交换 max 和 i 小标的元素
            mySwap(arr[max], arr[i]);
        }
    }
}

// 输出函数模板
template
void myPrint(T& arr){
    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++){
        cout << arr[i] << " ";
    }
    cout << endl;
}

void test(){
    int arr[5] = { 1, 2, 3, 4, 5 };
    int len = sizeof(arr) / sizeof(arr[0]);
    mySort(arr, len);
    myPrint(arr);   
}

int main(){
    test();
    system("pause");
    return 0;
}

运行结果： 

普通函数和模板函数的区别

区别：

• 调用普通函数时，可以发生自动类型转换（隐式类型转换）
• 调用函数模板时，如果使用自动类型推导方式，不会发生隐式类型转换
• 调用函数模板时，如果使用显示指定类型方式，可以发生隐式类型转换

普通函数调用测试代码：

#include
using namespace std;

int myAdd(int a, int b){
    return a + b;
}

void test(){
    int a = 10;
    char c = 'c';
    cout << myAdd(a, c) << endl;
}
int main(){
    test();
    system("pause");
    return 0;
}

运行结果：

 调用函数模板，自动类型推导方式

运行结果：

 调用函数模板，显示指定类型

运行结果：

普通函数和函数模板调用规则

调用规则：

• 如果函数模板和普通函数都可以实现（调用），优先普通函数
• 可以通过空模板参数列表来强制调用函数模板
• 函数模板也可以发生重载
• 如果函数模板可以发生更好的匹配，优先调用函数模板

①当函数模板和普通函数都可以调用，则优先调用普通函数

测试代码：

#include
using namespace std;

template
void myPrint(T a, T b){
    cout << "调用函数模板" << endl;
}

void myPrint(int a, int b){
    cout << "调用普通函数" << endl;
}

int main(){
    myPrint(10, 20);
    system("pause");
    return 0;
}

运行结果：

②通过空模板参数列表来强制调用函数模板

空模板参数列表

myPrint<>(10, 20);

函数模板加上空白方括号<>，强制调用函数模板（强调作用）

测试代码：

#include
using namespace std;

template
void myPrint(T a, T b){
    cout << "调用函数模板" << endl;
}

void myPrint(int a, int b){
    cout << "调用普通函数" << endl;
}

int main(){
    myPrint<>(10, 20); // 空模板参数列表
    system("pause");
    return 0;
}

运行结果： 

③函数模板发生重载

测试代码：

#include
using namespace std;

template
void myPrint(T a, T b){
    cout << "调用函数模板" << endl;
}

template
void myPrint(T a, T b, T c) {
    cout << "调用重载函数模板" << endl;
}

int main(){
    myPrint(10, 20);
    myPrint(10, 20, 30);
    system("pause");
    return 0;
}

运行结果：

 ④优先调用匹配的更好的函数模板

测试代码：

#include
using namespace std;

void myPrint(int a, int b){
    cout << "调用普通函数" << endl;
}

template
void myPrint(T a, T b){
    cout << "调用函数模板" << endl;
}

int main(){
    char a = 'a';
    char b = 'b';
    myPrint(a, b);
    system("pause");
    return 0;
}

运行结果：

提供了函数模板最好不要提供与之同名的普通函数，容易出现二义性

模板的局限性

局限性：

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

例如：比较两个数据类型的模板函数，传入数据的类型是数组或者自定义类型，则函数无法实现想要的要求。

测试代码：

运用具体化数据类型实现两个类之间的比较，具体化优先调用

-

具体化：template<>函数返回值  函数名（明确参数类型）

#include
#include
using namespace std;

class Person
{
public:
    Person(string name, int age) {
        this->m_Name = name;
        this->m_Age = age;
    }
    string m_Name;
    int m_Age;
};

template
bool myCompare(T& a, T& b){
    if (a == b){
        return true;
    }
    else{
        return false;
    }
}
// 使用具体化（优先调用）
template<>bool myCompare(Person& p1, Person& p2){
    if ((p1.m_Name == p2.m_Name) && (p1.m_Age == p2.m_Age)){
        return true;
    }
    else{
        return false;
    }
}

void test(){
    Person p1("李华", 20);
    Person p2("李华", 20);
    bool result = myCompare(p1, p2);
    if (result){
        cout << "相等" << endl;
    }
    else{
        cout << "不等" << endl;
    }
}

int main(){
    test();
    system("pause");
    return 0;
}

运行结果：

 除了具体化，还可以重载比较运算符

测试代码：

#include
using namespace std;

class Person {
public:
    Person(string name, int age) {
        this->m_Name = name;
        this->m_Age = age;
    }
    string m_Name;
    int m_Age;
};
// 全局函数重载 == 
bool operator==(Person& p1,Person& p2) {
    if ((p1.m_Age == p2.m_Age) && (p1.m_Name == p2.m_Name)){
        return true;
    }
    else {
        return false;
    }
}
//用模板函数比较两个类
template
bool myCompare(T& p1, T& p2) {
    if (p1 == p2) {
        return true;
    }
    else {
        return false;
    }
}

int main(){
    Person p1("李华", 18);
    Person p2("李华", 18);
    int result = myCompare(p1, p2);
    if (result) {
        cout << "相等" << endl;
    }
    else {
        cout << "不等" << endl;
    }
    system("pause");
    return 0;
}

运行结果：

---