模板

函数模板

template <typename T>
T add(T a, T b)
{
    return a + b;
}
int main()
{
    char a,b;
    int z,x;
    double q,w;
    add(a,b);
    add(z,x);
    add(q,w);
}

使用模板时，编译器会根据实参的类型来确定模板的实参类型，从而生成对应的函数。

形式

T add(vector<T> a, T b)
{
    return b;
}

传入引用

template ，用typename指代函数的参数类型，T是模板的形参。
使用范围仅限紧跟着的第一个函数声明，后续的函数声明不能使用模板。若使用模板但不使用，则需要强制类型转换才能调用这个函数，如：

add<int>(a,b); 

填入的所有元素必须保持一致。

类型转换

类型转换是模板的一大考点：

隐式类型转换：
即类似于char和int的转换

char a='a';
void sd(int);
sd(a);

强制类型转换：
即

int a=1;
char b='a';
b=(char)a;
强制类型转换，需要强制类型转换符，如：(char)a。

体现在模板上，就是

T add(vector<T> a, T b)
{
    return b;
}
add<int>(a,b);

重载

可以实现重载
当函数模板和普通函数重名时，编译器会优先选择函数模板，除非使用空模板参数列表。

template <typename T>
T add(T a, T b)
{
}
int add(int a, int b)
{
}
int main()
{
    add<>(int a=1,int b=0);
}
<>记为空模板参数列表。

特化

template<>add(person a,person b)
{
    if(a.?==b.?)
    return a;
    else return b;
}
貌似没什么用

类模板

template <class AH,class sd>
class person
{
    public:
    AN s;
    sd a;
    person(AH s,sd a);
}
int main()
{
    person<int,int> a(1,2);
}

用于创建类的模板，类模板的类名与模板名相同，类模板的类名后接尖括号，尖括号内为模板形参列表。

类型

类模板不会自动类型推导

template <class AH>
void nam(AH a)
{
    a.pp();
    //模板的函数
}

麻烦的东西，狗都不看
需要的时候直接把模板类的声明填进去就完事了。

继承

模板类的继承

template <class AH>
class person
{
    public:
    AH s;
    person(AH s);
}
class son():public person<int>
继承时必须强制类型转换
否则，子类也必须是模板类
如：
```c++
template <class AH>

class son():public person<AH>

现在，用户将类传入模板类person，person带着参数传入模板类son。