可变参数模板（Variadic Templates）-CSDN博客

可变参数模板

要解决的问题：

怎么创建一个拥有1个、2个或者更多的初始化器的类？
怎么避免创建一个实例而只拷贝部分的结果？
怎么创建一个元组？

最后的问题是关键所在：考虑一下元组！如果你能创建并且访问一般的元组，那么剩下的问题也将迎刃而解。
这里有一个例子（摘自“可变参数模板简述（A brief introduction to Variadic templates）”（参见参考）），要构建一个广义的、类型安全的printf()。这个方法比用boost::format好的多，但是考虑一下：

 
         const 
          string pi = “pi”; 
        
         const 
          char 
         * m =  
        
         “The value of %s is about %g (unless you live in %s).n”; 
        
         printf 
         (m,  pi, 3.14159,  “Indiana”);

这是除了格式字符串之外，没有其它参数的情况下调用printf()的一个最简单的例子了，所以我们将要首先解决：

 
         void 
          printf 
         ( 
         const 
          char 
         * s)     
        
         { 
        
         while 
          (s && *s) { 
        
         if 
          (*s==’%’ && *++s!=’%')   
         //保证没有更多的参数了  
        
         //%%（转义字符，在格式字符串中代表% 
        
         throw 
          runtime_error(“格式非法: 缺少参数”); 
        
         std::cout << *s++<<endl; 
        
         } 
        
         }

这个处理好之后，我们必须处理有更多参数的printf()：

 
         template 
         < 
         typename 
          T,  
         typename 
         ... Args>     
         // 注意这里的"..." 
        
         void 
          printf 
         ( 
         const 
          char 
         * s, T value, Args... args)    
         // 注意"..." 
        
         { 
        
         while 
          (s && *s) { 
        
         //一个格式标记（避免格式控制符） 
        
         if 
          (*s== 
         '%' 
          && *++s!= 
         '%' 
         ) {  
        
         std::cout << value;         
        
         return 
          printf 
         (++s, args...); 
         //使用第一个非格式参数 
        
         } 
        
         std::cout << *s++; 
        
         } 
        
         throw 
          std::runtime error( 
         "extra args provided to printf" 
         ); 
        
         }

这段代码简单地“去除”了开头的无格式参数，之后递归地调用自己。当没有更多的无格式参数的时候，它调用第一个（很简单）printf()（如上所示）。这也是标准的函数式编程在编译的时候做的(?)。注意,< <的重载代替了在格式控制符当中（可能会有错误）的花哨的技巧。（译注：我想这里可能指的是使用重载的<<输出操作符，就可以避免使用各种技巧复杂的格式控制字符串。）
Args…定义的是一个叫做“参数包”的东西。这个“参数包”仅仅是一个（有各种类型的值的）队列，而且这个队列中的参数可以从头开始进行剥离（处理）。如果我们使用一个参数调用printf()，函数的第一个定义(printf(const char*))就被调用。如果我们使用两个或者更多的参数调用printf()，那么函数的第二个定义(printf(const char*, T value, Args… args))就会被调用，把第一个参数当作字符串，第二个参数当作值，而剩余的参数都打包到参数包args中，用做函数内部的使用。在下面的调用中：

 
         printf 
         (++s, args…);

参数包args被打开，所以参数包中的下一个参数被选择作为值。这个过程会持续进行，直到args为空（所以第一个printf()最终会被调用）。
如果你对函数式编程很熟悉的话，你可能会发现这个语法和标准技术有一点不一样。如果发现了，这里有一些小的技术示例可能会帮助你理解。首先我们可以声明一个普通的可变参数函数模板（就像上面的printf()）：

 
         template 
         < 
         class 
          ... Types>  
        
         // 可变参数模板函数 
        
         //（补充：一个函数可以接受若干个类型的若干个参数） 
        
         void 
          f(Types ... args);  
        
         f();         
         // OK: args不包含任何参数 
        
         f(1);        
         // OK: args有一个参数: int 
        
         f(2, 1.0);   
         // OK: args有两个参数: int和double

我们可以建立一个具有可变参数的元组类型：

 
         template 
         < 
         typename 
          Head,  
         typename 
         ... Tail> 
        
         //这里是一个递归 
        
         //一个元组最基本要存储它的head（第一个（类型/值））对 
        
         //并且派生自它的tail（剩余的（类型/值））对 
        
         //注意，这里的类型被编码，而不是按一个数据来存储 
        
         class 
          tuple<Head, Tail...> 
        
         :  
         private 
          tuple<Tail...> {      
        
         typedef 
          tuple<Tail...> inherited; 
        
         public 
         : 
        
         tuple() { }  
         // 默认的空tuple 
        
         //从分离的参数中创建元组 
        
         tuple( 
         typename 
          add_const_reference<Head>::type v, 
        
         typename 
          add_const_reference<Tail>::type... vtail) 
        
         : m_head(v), inherited(vtail...) { } 
        
         // 从另外一个tuple创建tuple: 
        
         template 
         < 
         typename 
         ... VValues> 
        
         tuple( 
         const 
          tuple<VValues...>& other) 
        
         :    m_head(other.head()), inherited(other.tail()) { } 
        
         template 
         < 
         typename 
         ... VValues> 
        
         tuple& operator=( 
         const 
          tuple<VValues...>& other)   
         // 等于操作 
        
         { 
        
         m_head = other.head(); 
        
         tail() = other.tail(); 
        
         return 
          * 
         this 
         ; 
        
         } 
        
         typename 
          add_reference<Head>::type head()  
        
         {  
         return 
          m_head; } 
        
         typename 
          add_reference< 
         const 
          Head>::type head()  
         const 
        
         {  
         return 
          m_head; } 
        
         inherited& tail() {  
         return 
          * 
         this 
         ; } 
        
         const 
          inherited& tail()  
         const 
          {  
         return 
          * 
         this 
         ; } 
        
         protected 
         : 
        
         Head m_head; 
        
         }

有了定义之后，我们可以创建元组（并且复制和操作它们）：

 
         tuple<string,vector, 
         double 
         > tt( 
         "hello" 
         ,{1,2,3,4},1.2); 
        
         string h = tt.head();    
         // "hello" 
        
         tuple<vector< 
         int 
         >, 
         double 
         > t2 = tt.tail();

要实现所有的数据类型可能会比较乏味，所以我们经常减少参数的类型，例如，可以使用标准库中的make_tuple()函数：

 
         template 
         < 
         class 
         ... Types> 
        
         // 这个定义十分简单（参见标准20.5.2.2） 
        
         tuple<Types...> make_tuple(Types&&... t)    
        
         { 
        
         return 
          tuple<Types...>(t...); 
        
         } 
        
         string s =  
         "Hello" 
         ; 
        
         vector< 
         int 
         > v = {1,22,3,4,5}; 
        
         auto x = make_tuple(s,v,1.2);