函数模版入门

函数模版入门

1、入门小Demo

声明一个模版，告诉编译器后面代码中紧跟着T不要报错，T是一个通用数据类型

template <typename T> //typename 可以替换为class
void mySwap(T &a,T &b){
    T temp = a;
    a = b;
    b = temp;
}

1.1调用函数常用两种方法

1. 自动类型推倒

2. 显式指定类型

int a = 10;
int b = 20;
 //1、自动类型推倒
 mySwap(a,b);
 //2、显式指定类型
 mySwap<int >(a,b);

2、函数模版注意事项

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

int a = 10;
char b = 'a';
//mySwap(a,b);// a 和 b 类型不一致，将会报错

2. 模版必须要确定出T的数据类型，才可以使用

template <class T>
void func(){
    cout << "func 调用" << endl;
}

void test02(){
    func<int>();//这里如果不指定范型是int将会报错
}

3、函数模版案例-数组中排序

#include <iostream>
using namespace std;
//实现通用  对数组进行排序的函数
//规则  从大到校
//算法   选择排序
//测试  char  数组  int数组

//交换函数模版
template <class T>
void mySwap(T &a,T &b){
    T temp = a;
    a = b;
    b = temp;
}
//排序算法
template <class T>
void mySort(T arr[],int len){
    for(int i = 0;i <len;i++){
        int max  = i;//认定最大值的下标
        for(int j = i+1;j < len;j++){
            //认定的最大值  比 遍历出的数值要大，说明j下标的元素才是真正的最大值
            if(arr[max] < arr[j]){
                max = j;//更新最大值下标
            }
        }
        if(max != i){
            //交换max 和i元素
            mySwap(arr[max],arr[i]);
        }
    }
}
//提供打印数组模版
template <class T>
void printArray(T arr[],int len){
    for(int i = 0;i<len;i++){
        cout << arr[i] << " ";
    }
    cout << endl;
}
void test01(){
    // 测试char数组
    char charArr[] = "badcfe";
    int num = sizeof (charArr)/sizeof(char);
    mySort(charArr,num);
    printArray(charArr,num);
}
void test02(){
    int intArr[] = {7,5,1,3,9,2,4,6,8};
    int num = sizeof(intArr)/sizeof(int);
    mySort(intArr,num);
    printArray(intArr,num);
}
int main(){
    test01();
    test02();
    return 0;
}

4、普通函数与函数模版区别

1. 普通函数调用可以发生隐式类型转换

int myAdd01(int a ,int b){
    return a+b;
}
int a = 10;
int b = 20;
char c = 'c';
cout << myAdd01(a,b) << endl;
cout << myAdd01(a,c) << endl; //进行了隐式类型转换

2. 函数模版 用自动类型推导 ，不可以发生隐式类型转换

template <class T>
T myAdd02(T a ,T b){
    return a+b;
}
int a = 10;
int b = 20;
char c = 'c';
//cout << myAdd02(a,c) << endl; //报错 未进行隐式类型转换

3. 函数模版 用显式指定类型 ， 可以发生隐式类型转换

template <class T>
T myAdd02(T a ,T b){
    return a+b;
}
int a = 10;
int b = 20;
char c = 'c';
cout << myAdd02<int>(a,c) << endl; // 因为显式指定了int类型，可以发生隐式类型转换

5、 普通函数与函数模版调用规则

void myPrint(int a,int b){
    cout << "调用的普通函数"<< endl;
}
template<class T>
void myPrint(T a,T b){
    cout << "调用的模版"  << endl;
}

1. 如果函数模版和普通函数都可以调用，优先调用普通函数

int a = 10;
int b = 15;
myPrint(a,b); 

运行结果

调用的普通函数

2. 可以通过空模版参数列表 强制调用 函数模版
   空模版格式 函数名<>(参数列表)

int a = 10;
int b = 15;
//通过空模版参数列表，强制调用参数模版
myPrint<>(a,b); 

运行结果

调用的模版

3. 函数模版可以发生函数重载

template<class T>
void myPrint(T a,T b){
    cout << "调用的模版"  << endl;
}
template<class T>
void myPrint(T a,T b,T c){
    cout << "调用的重载的模版"  << endl;
}

myPrint(10,20,30);
myPrint<>(10,20,30);

运行结果

调用的重载的模版
调用的重载的模版

4. 如果函数模版可以产生更好的匹配，优先调用函数模版

myPrint('a','b');//char类型 可以调用普通函数，也可以调用模版，但是系统会优先使用更好的匹配，去调用函数模版

运行结果

调用的模版

6、模版的局限性

模版并不是万能的，有些特定数据类型，需要用具体化方式做特殊实现
举例如下：

#include <iostream>
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 <class T>
bool myCompare(T &a,T &b){
    if(a == b ){
        return true;
    }
    else{
        return false;
    }
}

//利用具体化Person的版本实现代码，具体化优先调用
/**
	template <>bool myCompare(Person &a,Person &b){
	    if(a.m_Name == b.m_Name && a.m_Age == b.m_Age){
	        return true;
	    }
	    else{
	        return false;
	    }
	}
*/

void test02(){
    Person p1("Tom",11);
    Person p2("Tom",10);

    bool ret = myCompare(p1,p2);
    if(ret){
        cout << "a == b" << endl;
    }else{
        cout << "a != b" << endl;
    }
}
int main(){
    test02();
}

运行结果：invalid operands to binary expression ('Person' and 'Person')
解决办法： 加入下面具体话版本实现代码

//利用具体化Person的版本实现代码，具体化优先调用
template <>bool myCompare(Person &a,Person &b){
  if(a.m_Name == b.m_Name && a.m_Age == b.m_Age){
        return true;
    }
    else{
        return false;
    }
}