初识C++函数模板及类模板

        在C语言中，是不支持函数的重载的，C++支持了函数的重载，使得我们可以让同一个函数传进不同的参数，我们就可以不用改变函数的名字，从而让一个函数支持更多的形参传递。但还是太麻烦了，有没有更好的方法，能让我们写一个函数就可以完成类似于多个函数重载呢？有的兄弟有的。这就是我们今天要讲到的函数模板和类模板。

1. 函数模板

        函数模板代表了一个函数家族，该函数模板在与类型无关，在使用时被参数化（类似于之前写的类，在写出来的时候只是一个设计图，被调用的时候才会真正开辟出空间），根据实参类型产生函数的特定类型版本。

        函数模板的格式是  template<typename T1 , typename T2 ………… typename Tn>

                                       返回值类型 函数名(参数列表) { 函数体 } 

        typename 也可以用class代替。

        下面我们用一个swap函数做例子：

template <class T>
void swap(T& t1 , T& t2)
{
    T tmp = t1;
    t1 = t2;
    t2 = tmp;
}

        第一行我们可以同时定义多个class的类型，在这个例子中我们只需要一个类型，就只需要定义一个class。class后面的 T 是它的名字，这个可以任意定，像变量名一样。在函数的形参部分，我们会定义两个 T 类型的形参，这两个形参在我们调用这个函数的时候，如果实参传递的是int类型，这个 T 类型也会转化为 int 类型，如果是double类型，就会转化为double类型。

template <class T>
void Swap(T& t1 , T& t2)
{
    T tmp = t1;
    t1 = t2;
    t2 = tmp;
}

int main()
{
    int a = 10;
    int b = 20;
    //这时传递的是int类型，所以上面的模板函数就会转化为
    //void Swap(int& t1 , int& t2)
    //{
    //    int tmp = t1;
    //    t1 = t2;
    //    t2 = tmp;
    //}
    Swap(a , b);
    
    double d1 = 1.1;
    double d2 = 2.2;
    //这时传递的是double类型，所以上面的模板函数就会转化为
    //void Swap(double& t1 , double& t2)
    //{
    //    double tmp = t1;
    //    t1 = t2;
    //    t2 = tmp;
    //}    
    swap(d1 , d2);

    return 0;
}

        函数模板只是一个蓝图，本身并不是函数，是编译器使用方式产生特定具体类型函数的模具。所以模板是把我们需要重复做的事情交给了编译器。在编译器编译的时候，编译器需要根据我们传进去的实参来推演出对应类型的函数以供调用，就像上面的例子中提到的。

        我们在使用不同类型的参数使用函数模板的时，称作函数模板的实例化。模板参数的实例化分为: 隐式实例化和显示实例化。

        隐式实例化就是让编译器根据我们传进去的类型自己推演模板参数的类型。

template <class T>
T1 Add(const T& t1 ,const T& t2)
{
    return t1 + t2;
}

int main()
{
    int a = 10;
    int b = 20;
    double d1 = 1.1;
    double d2 = 2.2;
                  //隐式实例化
    Add(a , b);   //这时会实例化为int Add(int& t1 , int& t2)
    Add(d1 ,d2);  //这时会实例化为double Add(double& t1 , double& t2)

    //Add(a , d1);  
    //这样会报错，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
    //通过实参 a 将T推演为int，通过实参 d1 将T推演为double类型,但模板参数列表中只有一个 T
    //编译器无法确定此处到底该将T确定为int 或者 double类型而报错
    //此时有两种解决方式：1.用户自己进行强制类型转换   2.使用显示实例化
    Add(a , (int)d1);  //这样强转就可以
    return 0;
}

        显示实例化就是我们在调用的函数名后用<>指定模板参数的实际类型。

int main()
{
    int a = 10;
    int d1 = 1.1;
    //显示实例化
    //如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。
    //这里就会先尝试把 d1 转换为 int 类型，再进行计算
    Add<int>(a , d1);
    return 0;
}

        一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。

        对于非模板函数和同名的函数模板，如果其他条件都相同，在调用的时候会优先调用非模板函数而不会用函数模板去实例化一个函数。如果模板会产生一个更好的函数，才会选择模板。

//只能处理int加法的函数
int Add(int a , int b)
{
    return a + b;
}
//函数模板
template <class T>
T Add(const T& t1 , const T& t2)
{
    return t1 + t2;
}

int main()
{
    Add(1 , 2);        //与非模板函数匹配
    Add<int> (1 , 2);  //调用编译器特化的Add
    return 0;
}

2. 类模板

        类模板和函数模板类似：

template<class T1, class T2, ..., class Tn>
class 类模板名
{
    //类成员定义
}；

        类模板的实例化和函数模板的实例化不一样，类模板实例化需要再类模板名字后加<>，然后将实例化的类型放进去就行，类模板在实例化后才是真正的类。

template<class T>
class A
{
    T a;
    T b;
}

int main()
{
    A<int> a1;
    return 0;
}