c++11边长模板参数

#include <iostream>
#include <cstdlib>

void print() {  // 这里结束模板递归地终止链
    std::cout << "I am empty function and I am called at last.\n";
}

template<typename T, typename... Types>
void print(T var1, Types... var2) {
    std::cout << var1 << std::endl;
    std::cout<<"sizeof...(var2)="<<sizeof...(var2)<<endl;//计算剩下的参数个数，如果参数为0,           则会调用print(void)
    print(var2...);
}

int main() {
    print(1,2,3.14, "Pass me any number of arguments",
        "I will print\n");
    system("pause");
    return 0;
}

计算变长参数个数，如上面注释：sizeof...(var2) 可以计算var2变长参数剩余个数

边长参数模板相当于一个模板的递归展开模型，但是它不是递归的，效率和循环的类似。使用的时候，要定义一个“递归”的出口，然后定义一系列的操作，操作的是以“递归”的方式进行的。

函数的调用过程类似于一个递归展开，先执行std::cout << var1 << std::endl;，然后递归地向下展开执行print(var2...);，此时的参数包也进行解包操作。

对于引用类型的，也是相似的操作，注意引用的位置和const的位置即可。
 

#include <iostream>
#include <cstdlib>
#include <string>

void log() {
    // 终止模板递归链
}

template<typename T, typename ...Args>
void log(const T& t, const Args&... params) {
    std::cout << t << std::endl;
    log(params...);  // 向下递归
}

int main() {
    log(1.22, 19, "hello world !");
    system("pause");
    return 0;
}

一般情况下参数包必须在最后面，例如：

template <typename T, typename ... Args> void fun(T t,Args ... args);//合法

template <typename ... Args, typename T> void fun(Args ... args,T t);//非法

2,解包 （包展开）

在实际使用时，拿到一个复合而成的包对没有并没有什么用，我们通常需要获得它里面内一个元素的内容。解包是把参数包展开为它所表示的具体内容的动作。

解包时采用“包扩展表达式”，就是包名加上三个点，如“Args...”。

例如：

假设我们有一个模板类Base：

template <typename ... Args>
class D1 : public Base<Args...>{};
或
template <typename ... Args>
class D2 : public Base<Args>...{};

解包用两种常见的形式：

1,直接解包（上面第一个）

D1<X,Y,Z> 相当于 D1:public Base<X,Y,Z>

2,先参与其他表达式再解包（上面第二个）

D2<X,Y,Z> 相当于 D2: public Base<X>, Base<Y>, Base<Z>

直观上理解就是在...所在的位置将包含了参数包的表达式展开为若干个具体形式。
 

template<typename...T>
void DummyWrapper(const T&... t){}


template<typename M>
auto  unpacker(const M& t)->decltype(t){
	cout << "," << t;
	return t;
}
template<typename T,typename... Args>
void write_line(const T& t, const Args&... data) {
	cout << t;
	DummyWrapper(unpacker(data)...);
	cout << endl;
}

write_line(1, 2, 3.14, "Pass me any number of arguments", "I will print");

出现一个问题：如果把typename M改为typename T,出现编译错误，原因是，匹配不到正确的函数，这个是因为生成了一份upacker特化，所以找不到函数，如果换成typename M,会生成对应的类型，这可能与typename作用域范围有关