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

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

#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;
}

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