函数模板与类模板

函数模板：
    将功能相同，类型不同的函数(类)的类型抽象成虚拟的类型。当调用函数(类实例化对象)的时候，编译器自动将虚拟的类型 具体化
    。这个就是函数模板(类模板)。目的是为了实现泛型，减少编程的工作量，增加函数的复用性
    关键字template
    注意，函数模板会编译两次：第一次：是对函数模板本身的编译，第二次：函数调用外 将T的类型具体化
template<typename T>
void SwapAll(T &a,T &b)
{
    T temp;
    temp = a;
    a = b;
    b = temp;
    return;
}
int main()
{   
    int a, b;
    a = 10;
    b = 20;
    SwapAll(a,b);
    cout << a << " " << b << endl;
    char c, d;
    c = 'a';
    d = 'b';
    SwapAll(c, d);
    cout << c << " " << d << endl;
    return 0;
}

    当函数模板和普通函数同名时，默认优先选择普通函数：
template<typename T>
void SwapAll(T &a,T &b)
{
    T temp;
    temp = a;
    a = b;
    b = temp;
    cout << "模板函数" << endl;
    return;
}
void SwapAll(int & a, int & b)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
    cout << "普通函数" << endl;
    return;
}
int main()
{   
    int a, b;
    a = 10;
    b = 20;
    SwapAll(a,b);
    cout << a << " " << b << endl;
}
    强制调用模板函数：
int main()
{   
    int a, b;
    a = 10;
    b = 20;
    SwapAll<>(a,b);//强制使用模板函数
    SwapAll<int>(a, b);//强制使用模板函数,且提前告知类型，则不需要编译器推导类型
    cout << a << " " << b << endl;
}
在编译器进行函数模板的类型推导时，必须保持传入的实参类型一直，若不一致则编译器不会采用模板函数
当然非你强制使用模板函数
void SwapAll(T a,T b)
{
    cout << "模板函数" << endl;
    return;
}
void SwapAll(int  a, int  b)
{
    cout << "普通函数" << endl;
    return;
}
int main()
{   
    SwapAll(10,20);//普通函数
    SwapAll(10, 'a');//普通函数
    SwapAll('a', 'b');//模板函数
    SwapAll<int>(10, 'a');//模板函数
}
函数模板可以重载

函数模板的局限性：
    当函数模板推导出T为数组或其他自定义类型数据 可能导致运算符不识别
第一种方法：重载运算符(推荐)
class Data1
{
    friend ostream& operator<<(ostream& out, Data1 ob);
private:
    int data;
public:
    Data1() {};
    Data1(int data)
    {
        this->data = data;
    }
};
ostream& operator<<(ostream& out, Data1 ob)
{
    out << ob.data << endl;
    return out;
}
template<typename T>
void SwapAll(T a)
{
    cout << a << endl;
    cout << "模板函数" << endl;
    return;
}

int main()
{   
    SwapAll('a');
    Data1 data(10);
    SwapAll(data);
    return 0;
}
该处，当模板函数识别到是Data1数据类型的时候，无法单纯的输出。必须重载运算符才能完成自定义类型的数据的
输出

第二种：具体化函数模板
template<typename T>
void SwapAll(T a)
{
    cout << a << endl;
    cout << "模板函数" << endl;
    return;
}
class Data1
{
    friend void SwapAll<Data1>(Data1 data);
private:
    int data;
public:
    Data1() {};
    Data1(int data)
    {
        this->data = data;
    }
};
//函数模板具体化
template<> void SwapAll<Data1>(Data1 data)
{
    cout << data.data << endl;
    cout << "函数模板具体化" << endl;

}
int main()
{   
    SwapAll('a');
    Data1 data(10);
    SwapAll(data);
    return 0;
}
编译器会先识别使用模板函数，但是发现自定义类型无法执行直接输出，就去找有没有具体化的函数模板

从上面的例子我们可以看出，无论是运算符的重载，还是函数模板的具体化。都是需要在类内处理的。

OK，了解完了函数模板后我们来看看类模板

---------------------------------------------------------------------------------------------------------------------------------

类模板：
    当多个类的功能相同，仅仅是数据类型不同时，使用类模板。类模板用于实现类所需要数据类型参数化
template<class T1,class T2>
class Date
{
private:
    T1 a;
    T2 b;
public:
    Date() {};
    Date(T1 a, T2 b)
    {
        this->a = a;
        this->b = b;
    }
    void showdata()
    {
        cout << a << "-----" << b<<endl;
    }
};
int main()
{   
    Date<int, int> ob1(10, 20);
    Date<int, char> ob2(10,'a');
    ob1.showdata();
    ob2.showdata();
    return 0;
}
这个地方要强点一点的就是，类模板需要手动指定转换类型。因为类的构造函数可以是无参构造，当我无参构造的时候是
无法判定类型的。这是一点于函数模板不同的地方

类模板的成员函数类外实现：
template<class T1,class T2>
class Date
{
private:
    T1 a;
    T2 b;
public:
    Date() {};
    Date(T1 a, T2 b);
    void showdata();
};
template<class T1,class T2>
Date<T1, T2>::Date(T1 a, T2 b)
{
    this->a = a;
    this->b = b;
}
template<class T1,class T2>
void Date<T1, T2>::showdata()
{
    cout << a << "----" << b << endl;
}
友元是一种定义在类外部的普通函数或类，但它需要在类体内进行说明，
为了与该类的成员函数加以区别，在说明时前面加以关键字friend。
友元不是成员函数，但是它可以访问类中的私有成员
函数模板作为类模板的友元：
    template<class T1,class T2>
class Date
{
    template<typename T3,typename T4>
    friend void showdata(Date<T3, T4>& ob);
private:
    T1 a;
    T2 b;
public:
    Date() {};
    Date(T1 a, T2 b);
};
template<class T1,class T2>
Date<T1, T2>::Date(T1 a, T2 b)
{
    this->a = a;
    this->b = b;
}
template<typename T3,typename T4>
void showdata(Date<T3,T4> &ob)
{
    cout << ob.a << "----" << ob.b << endl;
}
int main()
{   
    Date<int, int> ob1(10, 20);
    Date<int, char> ob2(10,'a');
    showdata(ob1);
    showdata(ob2);
    return 0;
}

普通函数作为类模板的友元
    相比于函数模板，普通函数就只需要将模板相关的关键字删除，并且指定模板的类型即可。如下：
template<class T1,class T2>
class Date
{
    friend void showdata(Date<int,int>& ob);
private:
    T1 a;
    T2 b;
public:
    Date() {};
    Date(T1 a, T2 b);
};
template<class T1,class T2>
Date<T1, T2>::Date(T1 a, T2 b)
{
    this->a = a;
    this->b = b;
}
void showdata(Date<int, int>&ob)
{
    cout << ob.a << "----" << ob.b << endl;
}
int main()
{   
    Date<int, int> ob1(10, 20);
    Date<int, char> ob2(10,'a');
    showdata(ob1);
    return 0;
}