C++学习第十八天（函数模板）

1. 模板
   1.1 模板的概念
   模板就是 建立通用的模具，大大提高复用性，特点：模板不可以直接使用，他只是一个框架；模板的通用并不是万能的。
   1.2 函数模板语法
   函数模板的作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体定制，用一个虚拟的类型来代表。

示例：

#include <iostream>

using namespace std;

//交换两个整数
void swapInt(int &a,int &b)
{
    int temp = a;
    a = b;
    b = temp;
}
//交换两个浮点数
void swapDouble(int &a,int &b)
{
    int temp = a;
    a = b;
    b = temp;
}
//利用模板提供通用的交换函数
template<typename T>
void mySwap(T &a, T &b)
{
    int temp = a;
    a = b;
    b = temp;
}
void test01()
{
    int a = 10;
    int b = 20;
    //利用模板实现两个数交换
    //1.自动类型推倒
    mySwap(a,b);
    //2.显示指定类型
    mySwap<int>(a,b);
    cout << "a= " << a << endl;
    cout << "b= " << b << endl;
}

int main(void)
{
    test01();

    return 0;
}

注意：函数模板利用关键字template;使用函数模板有两种类型：自动类型推倒、显示指定类型；模板的目的是为了提高复用性，将类型参数化。

1.2.1 注意事项：
·自动类型推倒，必须推导出一致的数据类型T才可以使用
·模板必须要确定出T的数据类型才可以使用

示例：

#include <iostream>

using namespace std;

//利用模板提供通用的交换函数
template<typename T>
void mySwap(T &a, T &b)
{
    int temp = a;
    a = b;
    b = temp;
}
//自动类型推倒，必须推导出一致的数据类型T才可以使用
void test01()
{
    int a = 10;
    int b = 20;
    char c = 'c';
    
    mySwap(a,b);//正确
    //mySwap(a,c);//错误，推倒不出一致的T类型
}

template<typename T>
void func()
{
    cout << "func调用" << endl;
}
void test02()
{
    //func();//错误，模板不能独立使用，必须确定出T的类型
    func<int>();//利用显示指定类型的方式给T一个类型，才可以使用模板
}

int main(void)
{
    test01();
    test02();

    return 0;
}

1.3 函数模板案例
利用函数模板封装一个排序的函数，可以对不同数据类型进行排序（算法为选者排序）从大到小排序，分别利用char数组和int数组进行测试。

示例：

#include <iostream>
#include <string.h>
using namespace std;
    
//交换函数模板
template<typename T>
void mySwap(T &a,T &b)
{
    T temp = a;
    a = b;
    b = temp;
}
//排序函数模板
template<typename T>
void mySort(T arry[],int len)
{
    for(int i=0;i<len;i++)
    {
        int max = i;//认定最大值下标
        for(int j = i+1;j<len;j++)
        {
            //认定的最大值比遍历出的数值要小，说明j下标的元素才是真正的最大值
            if(arry[max] < arry[j])
            {
                max = j;//更新最大值下标
            }
        }
        if(max != i)
        {
            //交换max和i元素
            mySwap(arry[max],arry[i]);
        }
    }
}

//打印模板函数
template<typename T>
void myPrint(T arry[],int len)
{
    for(int i=0;i<len;i++)
    {
        cout << arry[i] << "";
    }
}
void test01()
{
    char carry[] = "abcdef";
    int len = sizeof(carry)/sizeof(char);
    //cout << len << endl;
    mySort(carry,len);
    myPrint(carry,len);
}
void test02()
{
    int iarry[] = {2,3,5,7,8,9};
    int len = sizeof(iarry)/sizeof(int);
    //cout << len << endl;
    mySort(iarry,len);
    myPrint(iarry,len);
}
int main()
{
    //test01();
    test02();
    return 0;
}

1.4 普通函数和函数模板的区别
·普通函数调用时可以发生自动类型转换（隐士类型转换）
·函数模板调用时，如果利用自动类型推导，不会发生隐士类型转换
·如果利用显示指定类型的方式，可以发生隐士类型转换

示例：

#include <iostream>

using namespace std;

//普通函数
int myAdd1(int a,int b)
{
    return a+b;
}

//函数模板
template <typename T>
T myAdd2(T a,T b)
{
    return a+b;
}
void test01()
{
    int a =10;
    char c = 'c';
    cout << "和为 " << myAdd1(a,c) << endl;//109c的ascall马为99
    cout << "和为 " << myAdd1(a,c) << endl;//109（编译器版本不同这里不报错）
    cout << "和为 " << myAdd2<int>(a,c) << endl;//109
}

int main(void)
{
    test01();
    return 0;
}

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

#include <iostream>

using namespace std;

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

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

void test01()
{
    int a = 10;
    int  b = 10;
    char c = 'c';
    char d = 'd';

    myPrint(a,b);//默认调用普通函数
    myPrint<>(a,b);//利用空模板参数列表来强制调用函数模板
    myPrint(a,b,100);//这里不用空模板列表也会调用函数模板2
    //这里可以将类型转换为int调用普通函数，也可以自动类型转换为char调用函数模板
    myPrint(c,d);//编译器将调用函数模板
}

int main()
{
   test01();
    return 0;
}

总结：既然提供了函数模板，就不要提供普通函数，以免出现二重性。

1.6 函数模板的局限性

#include <iostream>
#include <string.h>

using namespace std;

class Person
{
public:
    Person(int age,string name)
    {
        m_age = age;
        m_name = name;
    }

    int m_age;
    string m_name;
};

template <typename T>
bool myCompare(T a, T b)
{
    if(a == b)
    {
        cout << "a = b" << endl;
        return true;
    }
    else
    {
        cout << "a != b" << endl;
        return false;
    }
}

//利用具体化Person的版本来实现比较两个对象，具体化优先调用
 template<> bool myCompare(Person p1, Person p2)//这里用引用方式传参的话会编译失败
{
    if(p1.m_name == p2.m_name && p1.m_age == p2.m_age)
    {
        cout << "两对相一样" << endl;
        return true;
    }
    else
    {
        cout << "两对相不一样" << endl;
        return false;
    }
}
void test01()
{
    int a =10;
    int b = 10;
    myCompare(a,b);
}

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

int main()
{
    //test01();
    test02();
    return 0;
}

额外话：利用具体化的模板，可以解决自定义类型的通用化；
学习模板并不是为了写模板，而是在STL能够运用系统提供的模板。