模版类！！！！

template <class T = int>//这个是默认类型，要是不是int是其他的也可以，比如下面的string
T add(T t1,T t2)
{
    return t1 + t2;
}

int main()
{
    cout << add<int>(1,2) << endl;
    cout << add(1,2) << endl;
    string str1 = "zhang";
    string str2 = "san";
    cout << add(str1,str2) << endl;
    return 0;
}
模板的编译机制！！！！！！！！！！！！！！！（重点）
1首先编译器并不是把模板编译生成能处理任何类型的这种逻辑的函数，（或者类）而是类的生成器’
2函数或者类模板的不同产生了不同函数，类实例
3编译：（尽享两次编译），第一次实在声明的地方，对模板本身进行编译（主要是语法检查），
接着会在调用的地方再次对进行编译（第二次才是类或者函数的实例），第二次编译也叫做延时编译
（其实使用函数模板，要比直接调用函数慢）

函数模板有两种调用形式隐式调用：add（100，200），编译器通过实参推演，完成实例化
并且这个跟普通函数的形式很想，如果也有普通函数，那么就会运行普通函数
显示调用：add<int>(19,22);

函数模版的特化（全特化）：模版特化是依赖于基础模版的，没有基础模版就没有模版特化！！！
当算法逻辑跟实际参数不匹配的时候就应该进行模版特化
模版
template <class T>
T add(T a, T b)
{
    return a + b;
}
例如：：c中const char* 的字符串，（原因是const char* 不能直接改变）
如下：：(特化)
    string str;
    template<>
    const char *add（const char*t1,const char* t2）
    {
        string str=string(t1)+string(t2);
        return str.c_str();
        
    }
优先级：不管是隐式调用还是显示调用；只要有类型匹配的函数实例就调函数
其次要是有参数类型匹配的特化，就调用特化，要是以上没有就调用基础模版

函数重载：同名函数的不同实现
template <>
const char* add(const char* t1,const char* t2)
{
    cout << "add函数模板的const char* 的特化模板" << endl;
    static string str3 = string(t1) + string(t2);
    s = str3.c_str()
    return  s;
}
template <>
int add(int a, int b)
{
    cout << "add函数模板的int类型的特化模板" << endl;
    return a + b;
}
两个不同的特化函数（也有函数重载）：但是名字相同，他们在底层也会生成不同的名字

泛型T即可以是单一类型，也可以是一个很大的组合类型？？？？
template <class T>//单一类型

void my_funct(T t)
{   cout<<"1"<<endl;
    cout << typeid (t).name() << endl;
    cout<<"1"<<endl;
}
template <class Ret,class Arg1, class Arg2>//很大的类型组合
void my_funct(Ret (*arg)(Arg1,Arg2))
{
     cout<<"2"<<endl;
    cout << typeid (Ret).name() << endl;
    cout << typeid (Arg1).name() << endl;
    cout << typeid (Arg2).name() << endl;
    cout << typeid (arg).name() << endl;
     cout<<"2"<<endl;
};

可变参   ...
可变参函数就是说用...表示的函数的参数类型和参数个数都是不定的
#include <iostream>
using namespace std;
void print()
{
    
}
Arg表示多个模板类型参数
arg表示多个函数参数
template <class Firstarg,class... Arg >
void print(Firstarg firstarg,Arg... arg)
{
    cout<<firstarg<<endl;
    print(arg...)
}

——————————————————————————————————————————————————
first of all
类模版不可以直接定义对象，是一个类的生成器；编译器根据指定的类型生成一个实体类（就是这个Person<string,int>）
类模版：类模版不会如同函数模版那样有自动推导功能；（也就是没有隐式调用）

有两种情况：
如果在template声明了，template <class T1=string ,class T2=int >可以使用 Person<string,int> p("gaowanxi",35); 
 也可使用Person<> p1("zhansan",18);

如果没有在template声明template <class T1 ,class T2 >，只能使用 Person<string,int> p("gaowanxi",35); 

类模板的继承，多态及类模板中的特殊属性的初始化（经典实例）
#include <iostream>
using namespace std;
//定义一个类模板
template <class T1,class T2>
class PERSON
{
private:
    T1 name;
    T2 age;
public:
    PERSON(T1 name,T2 age)
    {
        this->name=name;
        this->age=age;
    }
    virtual ~PERSON()=default;
    T1 getname()
    {
        return this->name;
    }
    T2 getage()
    {
        return  this->age;
    }
    virtual void showinfo()
    {
        cout<<this->name<<this->age<<endl;
    }
};
template <class T1,class T2,class T3>
class STU:public PERSON<T1,T2>
{
private:
    const  T3 _id;
    static int count;
public:
    STU(T1 name,T2 age,T3 id):PERSON<T1, T2>(name,age),_id(id)
    {
        count++;
    }

    void showinfo() override
    {
        cout<<this->getname()<<this->getage()<<this->_id<<
              this->count<<endl;
    }
    static int getcount()
    {
        return count;
    }

};
template <class T1,class T2,class T3>
int STU<T1,T2,T3>::count=0;
int main()
{
    PERSON<string,int> p("www",22);
    p.showinfo();
    PERSON<string,int> *p1=new STU<string,int,int>("ssk",26,1001);
    p1->showinfo();

        return 0;
}

类模板中的特化：
#include <iostream>
using namespace std;
template <class T>
class A
{
public:
    A()
    {
        cout << "A的基础类模板" << endl;
    }
};
template <>
class A<int>
{
public:
    A()
    {
        cout << "A的int型的全特化" << endl;
    }
};
template <class T>
class A<T*>
{
public:
    A()
    {
        cout << "A类模板的指针类型的偏特化" << endl;
    }
};
template <class Ret,class Arg1,class Arg2>
class A<Ret (*)(Arg1,Arg2)>
{
public:
    A()
    {
        cout << "A类模板的函数指针类型的偏特化" << endl;
    }
};
int add(int a, int b)
{
    return a + b;
}
int main()
{
    A<float> a;
    cout << "-------------------" << endl;
    A<int> a1;
    cout << "-------------------" << endl;
    A<int*> a2;
    cout << "-------------------" << endl;
    A<int (*)(int,int)> a3;
    return 0;
}

函数模版的特化

#include <iostream>
using namespace std;
template <class T = int>
T add(T t1,T t2)
{
    cout << "add函数模板的基础模板" << endl;
    return t1 + t2;
}
template <>
const char* add(const char* t1,const char* t2)
{
    cout << "add函数模板的const char* 的特化模板" << endl;
    string str  =  string(t1) + string(t2);
    return str.c_str();
}
template <>
int add(int a, int b)
{
    cout << "add函数模板的int类型的特化模板" << endl;
    return a + b;
}
int add(int a, int b)
{
    cout << "add函数实例" << endl;
    return a + b;
}
int main()
{
    //1.显式调用时，有特化模板时的调用优先级。当有与实参类型匹配的特化模板时会被优化调用。
    cout << add<int>(1,2) << endl;
    cout << add<const char*>("zhang","san") << endl;
    //2.隐式调用时：有特化模板时的调用优先级。当有与实参类型匹配的特化模板时会被优化调用。
    cout << "-----------------------------" << endl;
    cout << add(1,2) << endl;
    cout << add("zhang","san");
    return 0;
}