一、说明

很多技术学会了是学会了，但是转眼就会忘记。这也是很多技术被束之高阁的主要原因，没有应用场景。当然，有了应用场景不用，那是另外一回事。那么，一个技术的产生一定是从实际的应用场景中来，但是传播的过程中，可能反而让很多人忘记了这个应用场景是什么。所以今天就聊聊这个变参模板到底怎么用，给出一些在实际场景中模拟的例子，让人一看就明白的那类。这样，有了同样类似的场景，就可以考虑把这个变参模板应用上去。
在前面的分析中可以看到，一个变参模板类一般分为三部分，第一部分是模板类的前置声明用来声明一个可变参数模板类；然后是一般的展开形式，也就是通过偏特化来实现部分可展开的模板类，最后就是反复提到的终止定义模板类来保证递归等的结束判断，这里一般是一个特化的类或者是一个全实例化的类。
在实际的应用中，就可以把这块专门编写模板封装起来，供外部调用。

二、应用

下面举出三个场景来应用变参模板：

1、实现工厂类
如果在实际场景中，需要一个工厂模式（可不要说从来没遇到过用工厂模式），这个工厂模式有不确定多个参数和类型需要传递，怎么办？传统的方式可以写很多个重载函数，或者写一个最长，然后每个都有默认参数，根据实际传入的参数来决定到底采用哪种方式来创建实例。但是这样做显得代码臃肿且不易维护和扩展。当然，也可以抽象一个类（接口），子类来继承，通过动态创建不同的类来实现，但这就需要维护者去编写这个继承类，这或多或少也会让开发者感到有些不好理解，特别是如果这个父类被封装到一个DLL库中，看不到实际的代码时，更是如此。那么变参模板就很容易实现：
先看一下如果不使用变参模板：

template
T* Instance()
{return new T();
}template
T* Instance(T0 arg0)
{return new T(arg0);
}template
T* Instance(T0 arg0, T1 arg1)
{return new T(arg0, arg1);
}
//..............
//当然后面还可以写更多个参数类型的
#include class Example0
{
public:Example0(int) {std::cout << "class instance example0!" << std::endl;}
};class Example1
{
public:Example1(int, double) {std::cout << "class instance example1!" << std::endl;}
};
int main()
{Example0* pa = Instance(3);Example1* pb = Instance(3,2.0);
}

再看使用变参模板：

#include 
#include 
#include class Example0
{
public:Example0(int) {std::cout << "class instance example0!" << std::endl;}
};class Example1
{
public:Example1(int, double) {std::cout << "class instance example1!" << std::endl;}
};
struct Example2
{Example2(int, double,std::string) {std::cout << "struct instance example3!" << std::endl;}
};
template
std::shared_ptr Instance(Args&&... args)
{return std::make_shared(std::forward(args)...);//return std::shared_ptr(new T(std::forward(args)...));
}
void TestInstance()
{std::shared_ptr p0 = Instance(1);std::shared_ptr p1 = Instance(1, 2.0);std::shared_ptr p2 = Instance(1, 2,"Test");
}
int main()
{TestInstance();return 0;
}

这样写比上面简洁多了，这就是标准进步的结果。

2、实现类似代理委托
如果有c#或者Java开发经验的就会知道，其中的委托delegate非常好用。各种函数都可以轻易的转发调度。那么，在c++中用变参模板就可以近似实现类似的功能,而且比之更灵活，看下面的例子：

template 
class  CppDelegate
{
public:CppDelegate(T* t, R(T::* func)(Args...)) :t_(t), func_(func) {}R operator()(Args&&... args){return (t_->*func_)(std::forward(args) ...);}private:T * t_;R(T::* func_)(Args...);//万能函数
};template 
CppDelegate CreateDelegate(T* t, R(T::* f)(Args...))
{return CppDelegate(t, f);
}class DgEx
{
public:void MyFunc0(int d) { std::cout << d << std::endl; }void MyFunc1(int d, std::string s) { std::cout << s << d << std::endl; }int MyFunc2(std::string s,int d) { std::cout << s << std::endl; return d; }
};void TestDelegate()
{DgEx de;auto d0 = CreateDelegate(&de, &DgEx::MyFunc0);d0(16);auto d1 = CreateDelegate(&de, &DgEx::MyFunc1);d1(6, "display:");auto d2 = CreateDelegate(&de, &DgEx::MyFunc2);int r = d2("this is test!",3);std::cout << "return value is:" << r << std::endl;
}
void TestDelegate();int main()
{TestDelegate();return 0;
}

这里面有一个万能函数，不知道还记不记得“C++变参函数实现三步曲之三C++11变参模板模式”文中就提到了这种方式。不过这个还是比较功能单一，大家可以在这个基础上进行扩展。

3、std::bind的变参绑定
这个在前面提到的文章中也有过描述，看一个例子：

#include 
#include 
#include class MyBind
{
public:templatevoid Call(T&... args){{func_ = std::bind(&MyBind::Test, this, args...);std::cout << "test bind args..." << std::endl;func_();}}templatevoid Test(T&... args){std::cout << "call Test " << std::endl;}std::function func_;};int  TestMyBind()
{int a = 6;double b = 3.9;std::string c{ "test bind" };MyBind myBind;myBind.Call(a, b, c);return 0;
}

都是需要认真看才能搞清楚，所以看这些例子，还是要仔细静下心来，弄明白了，就真的掌握了。不要看看会，就觉得会了，自己写一个试试，可能会有意外的惊喜。
这三个例子，都是比较好的应用场景，在这些简单的例子的入门引导下，就可以不断的在实际的应用中完善修改，最终形成一个符合自己工程应用的模块，最合适的才是最好的。

三、总结

学以致用，这句话说起来容易，可做起来真难啊。如果不能深刻的理解一门技术，就无法自如的应用他，而只能照猫画虎的外向型模仿。不过，这种外向型模仿却又是深刻理解的前提和基础。学习本身就是一个由表及里，由外到内的过程。越是学习应用的多，对一门技术的理解就会越发的深刻。而反过来，应用这门技术就会越发的灵活自如。
计算机技术就是如此，多读书，勤实践，不断的从理论到实践并不断的反馈自己对理论的理解，如此往复，其期可待。