C++语法系列之模板进阶

---

前言

本次会介绍一下非类型模板参数、模板的特化(特例化)和模板的可变参数，不是最开始学的模板

---

一、非类型模板参数

字面意思,比如：

template<size_t N = 10>
或者
template<class T,size_t N = 10>

比如：静态栈就可以用到，并且由于变长数组的原因，这样可以更好的使用

template<typename T,size_t N = 10>
class Stack {
private:T a[N];int _top;
};
int main()
{Stack<int> s1;Stack<double, 20> s2;return 0;
}

二、模板的特化

模板的特化是C++98中提出的，他处理一种什么情况呢？就是比如说我想对这个模板是int的类型是进行不一样的操作，其余都一样，就用上了模板的特化，
1.非类模板的特化

template<typename T>
void func(T a)
{cout << "void func(T a)" << endl;
}
template<>
void func<int>(int a)
{cout << "void func<int>(int a)" << endl;
}
int main()
{func(double());func(int());return 0;
}

通过这个来看要求：需要有一个主模板，不然会报错，<>中不写内容，函数名后加<>，里面写类型，形参与主模板的对应。
如果还有重载的int优先走哪个？当然是重载的然后是模板的

2.类模板的特化
规则与上面类似，但是现在是类名后加<>，里面放类型

template<typename T>
class A {
public:A() {cout << "class A " << endl;}
};
template<>
class A<double> {
public:double a;A() {cout << "class A<double> " << endl;}
};int main()
{A<int> a;A<double> b;return 0;
}

三、全、偏、部分特化

类模板的特化里面呢又搞了几个东西，偏特化，全特化，部分特化
我这里就用大白话讲了，让大家能够理解
全特化就是所有的类型全部具体，偏就是全不具体，部分就是一部分具体，上代码理解一下
全特化：（非类模板只支持全特化，想写其他的可以去玩重载）

template<typename T>
class A {
public:A() {cout << "class A " << endl;}
};
template<>
class A<double> {
public:A() {cout << "class A<double> " << endl;}
};
template<>
class A<char> {
public:A() {cout << "class A<char> " << endl;}
};
int main()
{A<int> a;A<double> b;A<char>c;return 0;
}

偏特化：比如我就想对所有的指针类型进行特殊处理，所有的指针类型也写不过来，所以这里用上了偏特化

template<typename T>
class A {
public:A() {cout << "class A " << endl;}
};
template<typename T>
class A<T*> {
public:A() {cout << "class A<T*> " << endl;}
};
template<typename T>
class A<T(*)(int,int)> {
public:A() {cout << "class A < T(*)(int, int)>" << endl;}
};
int main()
{A<int> a;A<double*>b;A<int*>c;A<void(*)(int, int)> d;A<int(*)(int, int)> e;return 0;
}

部分特化，参考全特化和偏特化，就是一部分显示出来，一部分不显示

template<typename T,typename G>
class A {
public:A() {cout << "class A" << endl;}
};
template<typename T>
class A<T*,int> {
public:A() {cout << "class A<T*,int> " << endl;}
};
int main()
{A<int, int> a;A<int*, int> b;A<double*, int> c;return 0;
}

没啥意思，感觉用处也不大

四、模板的可变参数

这里就是C++11搞出来的了
最开始学的能够接受任意个参数的函数也是C语言用到最多的就是printf和scanf，注意：这里的实现用的并不是模板的可变参数，因为那个时候还没有C++11（doge，他们是通过宏来实现的奥。
C++里用这个的例子

tuple是元组奥，可能你们没见过，后面在STL里面会讲，也是C++11搞出来的东西

emplace_back也是后面要提到的，先留个底
一个可变参数模板就是一个可接受可变数目参数的模板函数或者模板类，可变数目的参数称为参数包，存在两种参数包：模板参数包，表示零个或者多个模板参数，函数参数包，表示零个或者多个参数
先看写法

template<typename T,typename... Args>
void foo(const T& t,const Args&... rest)

//Args是一个模板参数包，rest是一个函数参数包，均表示0个或者多个函数参数
编译器从函数的实参推断模板参数类型，对于一个可变参数模板，编译器还会推断包中参数的数目
当我们要知道包里面有多少元素时，可以使用sizeof…运算符，类似sizeof，也返回一个常量表达式

template<class T,class...Args>
void print(T value,Args...args)
{cout << sizeof...(args) << endl;
}
int main() {print(1, 2,4,4);print(1);print(1, 2, 3, 4,"xxxxxxxx");return 0;
}

五、编写可变参数函数模板

可变参数函数通常是递归的，第一步调用处理包中的第一个实参，然后用剩余实参调用自身，所以这里需要两个参数，比如：

template<class T>
void print(T val)
{cout << val << endl;
}
template<class T,class...Args>
void print(T val, Args...args)
{cout << val << ' ';print(args...);
}

当包里剩一个参数的时候就会调用上面的print()，否则就递归自身
这样是不有一个问题啊，我无法print()什么也不传
可以再分装一个函数，然后将第一个函数改成无参，这样当递归到参数包没有参数就会调用那个函数

void _print()
{cout << endl;
}
template<class T,class...Args>
void _print(T val, Args...args)
{cout << val << ' ';_print(args...);
}
template<class...Args>
void print(Args...args)
{_print(args...);
}
int main()
{print(1, 2);print(1, 2,"xxxxxxxxxx");print(1);print();return 0;
}

Warning:当定义可变参数的print时，非可变参数的版本的声明必须在作用域中，不然会无限的去递归。

六、逗号表达式展开参数包

这种不需要递归来实现，是直接在函数体中展开的，

template<class T>
void _print(T val)
{cout << val << ' ';
}
template<class ...Args>
void print(Args... args)
{int arr[] = { (_print(args),0)...};cout << endl;
}
int main()
{print(1, 2);print(1, 2,"xxxxxxxxxx");print(1);return 0;
}

这里了解一下就行，至于为什么用逗号表达式，因为这是int类型的数组，而_print返回值是void,所以扔个0就行，建议记下来也没啥用

template<class T>
int _print(T val)
{cout << val << ' ';return 1;
}
template<class ...Args>
void print(Args... args)
{//int arr[] = { (_print(args),0)...};int arr[] = { _print(args)... };cout << endl;
}

七、转发参数包

实际上就是玩forward

八、emplace_back

刚才看了库里的实现，既然是模板的可变参数，说明就可以这么玩

int main()
{vector<pair<int, int>> v;v.emplace_back(1, 2);v.push_back(1, 2);//error,push_back不可以这么玩return 0;
}

为什么emplace_back支持这么玩？

//别忘了Args&&…args这个不是右值引用，是万能引用
看第一行，“这个新元素是使用args作为其构造函数的参数就地构造的”相当于直接在容器里面构造，
而push_back是构造 + 移动构造
性能上没有差很多，因为有了移动构造的缘故,这一步的开销不是很大
想具体玩差别可以找我上一期的myspace::string，自己调用一下。

总结

这集意义不大，模板的可变参数用的也不多，了解了解就行，emplace_back还是很有用的。明天更新C++11，这个东西巨多，《C++ Primer》第五版这本书上描述了巨多新特性，我会通读一下然后讲一下有用的。模板的可变参数和右值都是C++11里面的，已经绕过了这座大山。