Cpp6 — 模板

模板：这里有一个概念：泛型编程---针对广泛的类型去写代码编程。之前都是针对具体的类型进行编程。

模板分为函数模板和类模板。

函数模板

当我们想要使用一个swap可以用作多种类型时，可以使用模板。这样我们就可以不使用重载，不用多写一个函数。

template<>//模板参数（模板类型）--类似函数参数（参数对象）

template//typename/class是关键字，T是类型名，可以随便取，其代表一个模板类型（虚拟类型），即可以是任意类型。

模板不支持分离编译，也就是声明在.h，定义在.cpp，这样是不支持的。

template
void swap(T& x1,T& x2)
{
    T tmp = x1;
    x1 = x2;
    x2 = tmp;
}

int main()
{
    int a = 1, b = 2;
    swap(a,b);//可以
    double c = 1.1, d = 2.2;
    //编译器会通过实参推形参的类型T分别为int和double，这种方式是隐式实例化
    swap(c,d);//可以
    swap(a,c);//不可以
    return 0;
}

它们两调用的是同一个函数吗？

不是（可以看地址或汇编），它们只是类似，其实建立的栈帧、使用的指令都是不一样的。它们会在预处理阶段推演出对应代码需要的类型。

 函数模板的实例化

要经历：1.模板参数推演2.推演参数实例化

在解决问题时，调用的并不是同一个函数，例如解决int类型交换、double类型交换，在底层看，两个函数的地址是不一样的。

其实标准库里有一个swap，我们可以直接使用

注意，异或针对整型可以，但是对于浮点型那些，并不好 

注意如果传值传参，自定义类型是需要调用拷贝构造的。所以尽量用传引用传参。

传参之前（就会实例化，所以是在推演时报错的）

 这样可以

 第十一节1:09:00

//推演矛盾
template

T Add(const T& left, const T& right)
{
    return left + right;
}


int main()
{
    Add(1, 2);//编译。编译器自动推演，也叫隐式实例化
    Add(1.1, 2);//报错，编译不通过，模板T不明确，传参之前的一步错了，因为传参是可以隐式类型转换的。是在推演实例化时出错的，因为不知道是该推演成double类型还是int类型
    Add((int)1.1, 2);//可以自己强制类型转换
    Add(1.1, (double)2);

    //显式实例化。不用你编译器推了，我直接指定了。
    Add(1.1, 2);
    Add(1.1, 2);

    return 0;
}
//上面这个问题也可以给两个模板参数



template//class和typename混用也是可以的。虽然是int和double，类型不一样，但是计算时是会隐式类型转换的，加完之后虽然是double类型，但是返回值是int，所以会有一个警告
T1 Add(const T1& left, const T2& right)
{
    return left + right;
}








template
T* Func(int n)
{
    T* a = new T[n];
    return a;
}

//如果有这样一个函数，直接调用这个函数是调不成的，因为编译器无法推演出返回值，没办法指定返回值，参数是一个跟T没有关系的返回值，是一个其他类型，这种必须显示实例化才能调用
Func(10);//不行
Func(10);



//下面这两个可不可以同时存在？可以，调用的时候怎么走呢？
// 专门处理int的加法函数
int Add(int left, int right) 
{
    return left + right; 
}
// 通用加法函数
template
T Add(T left, T right) 
{
    return left + right; 
}

void Test() 
{
    Add(1, 2);       // 与非模板函数匹配，编译器不需要特化 
    Add(1, 2);  // 调用编译器特化的Add版本
}
//编译器编译的时候不会有那个函数模板，是先去找有没有参数类型匹配的函数，如果有，就会优先调用，如果没有，才去找函数模板去实例化一个int的。有现成的先用现成的






//那么如果是这样的呢？
template
T Add(T left, T right) 
{
    return left + right; 
}


template
T1 Add(T1 left, T2 right) 
{
    return left + right; 
}

Add(1.1, 2.2);//是调用第一个还是第二个呢？调用第一个
Add(1.1, 2);//这个是去调第二个

类模板

类模板都是显式实例化

当知道要开多少空间时，可以直接(100)给，例如知道要存100个数据，就提前给好，这样就能避免扩容时消耗

类模板的声明和定义分离

模板不支持分离编译。不支持声明放在.h，定义放在.cpp，原因：进阶讲

在同一个文件可以声明和定义分离，有时会编译报错，因为要在类外面使用类里面模板参数时，需要指定类域，而且不是这样指定Stack::应该是Stack::，2:28:00

有些地方会把模板所在文件改名成hpp，hpp的意思是告诉我们它不仅有声明，还有实现，其实.h就可以，甚至不加.h都可以

模板也可以给缺省参数，不过它给的是类型

template

就算给了缺省类型，实例化的时候也要写<>。例如：Stack<> s1;

 类模板的使用情况：如果一个要存char一个要存int