模板和泛型编程的相关知识（函数模板）

上篇博客中讲述了多态的相关知识，其中静态多态有两种：函数重载和泛型编程。函数重载在博客中已经解释过，接下来看看泛型编程的相关知识。
泛型编程：编写与类型无关的逻辑代码，是代码复用的一种手段，而模板就是泛型编程的基础。
模板：模板分为函数模板和类模板。
具体来介绍函数模板与类模板。
《一》、函数模板
函数模板:函数模板代表了一个函数家族，该函数与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
模板的实例化：模板本身不是类或函数，编译器用模板产生指定的类或者函数的指定类型版本，产生模板特定类型的过程称为函数模板实例化。
下面举例说明为：

#include<iostream>#include<string.h>using namespace std;template <class T>T Add(T a, T b){    return (a + b);}int main(){    cout << Add(2, 3) << endl;    cout << Add(4.5, 6.45) << endl;    cout << Add<int>(4.5, 6.45) << endl;    cout << Add(4,(int)6.5) << endl;    system("pause");    return 0;}

结果显示为：

在此举例中会发现Add<int>(4.5, 6.45) 和Add(4,(int)6.5).它们分别是显示实例化和隐式实例化，若给成Add(4,6.5)这种形式编译器无法进行编译，因为其各自的类型不一致。而在显式实例化中编译器会自动生成一个函数。

另外要注意的是模板被编译了两次。1.实例化之前，检查代码本身，查看是否出现语法错误，但不是每个错误均可找出。
2.在实例化期间，检查末班代码，查看调用的是否都有效。如：实例化类型不支持某些函数调用。

template <class T>T Add(T a, T b){    return (a + b)}int main(){    /*cout << Add(2, 3) << endl;    cout << Add(4.5, 6.45) << endl;    cout << Add<int>(4.5, 6.45) << endl;    cout << Add(4,(int)6.5) << endl;*/    system("pause");    return 0;}```该模板可以变异通过，但是在实例化的编译中无法通过编译，因为  return (a + b)后面缺少分号。**类型形参转换**：一般不会转换实参匹配已有的实例化，而是会产生新的实例。编译器会执行两种转换：1、const 转换：接收const引用或者const指针的函数分别用非const对象的引用或者指针来调用。<div class="se-preview-section-delimiter"></div>

这里写代码片
“`

2、数组或函数到指针的转换：如果模板形参不是引用类型，则对数组或函数类型的实参应用常规指针转换。
数组实参将当做指向其第一个元素的指针，函数实参当做指向函数类型的指针。

template<class T>void Funtest(const T &a){    cout << typeid(a).name() << endl;    cout << a << endl;}int main(){    int a[10];    Funtest(a);    system("pause");    return 0;}

结果如图所示：

2、数组或函数到指针的转换：如果模板形参不是引用类型，则对数组或函数类型的实参应用常规指针转换。
数组实参将当做指向其第一个元素的指针，函数实参当做指向函数类型的指针。
具体举例如下：

template<class T>void Funtest(const T a){    cout << typeid(a).name() << endl;    cout << a << endl;}int main(){    int a[10];    Funtest(a);    system("pause");    return 0;}template<class T>void Funtest(const T a){    cout << typeid(a).name() << endl;    cout << a << endl;}int main(){    int a[10];    Funtest(a);    system("pause");    return 0;}

结果如图显示：

相同若传函数，则其类型为函数指针类型。

模板参数
模板形参：类型形参，非类型形参。
模板形参名字只能在模板形参之后到模板声明或定义之前使用，遵循名字屏蔽原则。

typedef int T;template<class T>void Funtest(T t){    cout << "t type" << typeid(t).name() << endl;    /*return a + b;*/};T g;int main(){    cout << "g type" << typeid(g).name() << endl;    Funtest(2);    system("pause");    return 0;}

显示结果为：
非模板类型参数：非模板类型形参是模板内部定义的常量，在需要常量表达式的时候，可以使用非模板类型参数。具体举例如下:

template<class T,int N>void Funtest(T(&arr)[N]){    for (int i = 0; i < N; i++)    {        arr[i] = 1;    }}int main(){    int a[4];    double b[4];    Funtest(a);    Funtest(b);    system("pause");    return 0;}

其中的int N为非模板类型的形参。N不同所代表的函数也不同。

模板形参说明：
1、模板形参表使用<>,和函数参数列表一样，跟多个参数时必须用逗号隔开，类型可以相同可以不同。例如：template

template<class T>T max(const T&a, const T&b)//给成引用节省空间{    return a > b ? a : b;}              //若是三个进行比较则要进行重载template<class T>T max(const T&a, const T&b, const T&c){    //1.return max(a, b) > c ? max(a, b) : c;    //return max(max(a, b), c);    const T&temp = max(a, b);    return temp > c ? temp : c;}int main(){ max(1, 2);    max<>(1, 5);    max(2, 5, 8);    max(1.5, 5.5);    system("pause");    return 0;}

当然该模板并不能进行字符串的比较，那么应该怎么办呢？
例如：

template <class T>int compare(T a, T b){    if (a > b)        return 1;    if (a < b)        return -1;    return 0;}int main(){    char*a = "hello";    char*b = "world";    cout << compare(a, b) << endl;    system("pause");    return 0;}结果会发现他比较的仅是这两者的地址大小，答案并不正确

下面我们又提出了解决方法—-特化
模板函数特化：如两个字符串的比较，我们给出特化形式为

template<>int compare<const char*>(const char* const a,const char* const b){return strcmp(a,b);}

结果修正为：

template <class T>int compare(T a, T b){    if (a > b)        return 1;    if (a < b)        return -1;    return 0;}template<>int compare<const char*>(const char*const a, const char* const b){    return strcmp(a, b);}int main(){    char*a = "hello";    char*b = "world";    cout << compare(a, b) << endl;    system("pause");    return 0;}

最后关于特化：特化不能出现在模板实例的调用之后，应该在头文件中包含模板特化的声明，然后使用该特化版本的每个源文件包含头文件。