【C/C++】C++11 Variadic Templates

Variadic Templates

1、function template：利用“参数个数逐一递减”的特性，实现递归函数调用

template <typename T, typename... Types>
void func(const T& firstArg, const Types&... args) {
    处理 firstArg
    func(args...);
}

例一、实现类似 python 3 的 print()

 void print() { cout << endl; }    // 边界条件，当args为0个时调用

 template <typename T, typename... Types>
 void print(const T& firstArg, const Types&... args) {　　
     cout << firstArg << ' ';
     print(args...);
 }

 int main() {
     print(7.5, "hello", bitset<>(), );    // print "7.5 hello 0000000101111001 42"
     return ;
 }

如果同时存在函数

template <typename... Types>
void print(const Types&... args) {
    ...
}

void print(const T& firstArg, const Types&... args) 与 void print(const Types&... args) 可以共存，可以编译通过。

但前者比较特化，后者比较泛化，共存时永远不会调用后者。

例二、模拟 C <cstdio> 的 printf()，引自 stackoverflow

 void Printf(const char* s) {
     while (*s) {
         if (*s == '%' && *(++s) != '%')
             throw runtime_error("invalid format string: missing arguments.");
         cout << *s++;
     }
 }

 template <typename T, typename... Types>
 void Printf(const char* s, const T& firstArg, const Types&... args) {
     while (*s) {
         if (*s == '%' && *(++s) != '%') {
             cout << firstArg;
             Printf(++s, args...);
             return;
         }
         cout << *s++;
     }
 }

 int main() {
     int* pi = new int;
     Printf("[%p] %s = %f\n", pi, "This is pi", 3.1415926);    // print "[0x21fcc20] This is pi = 3.14159"
     return ;
 }

2、class template：利用“参数个数逐一递减”导致“参数类型也逐一递减”的特性，实现递归继承或递归复合

例一、对 first 和 last（头尾元素）的特别处理（模板偏特化+递归）

 // 使用tuple index和max index打印元素
 template <int IDX, int MAX, typename... Args>
 struct print_tuple {
     static void print(ostream& os, const tuple<Args...>& args) {
         os << get<IDX>(args) << (IDX +  == MAX ? "" : ", ");
         print_tuple<IDX + , MAX, Args...>::print(os, args);
     }
 };

 // 递归结束的偏特化
 template <int MAX, typename... Args>
 struct print_tuple<MAX, MAX, Args...> {
     static void print(ostream&, const tuple<Args...>&) {}
 };

 // output operator for tuple
 template <typename... Args>
 ostream& operator<<(ostream& os, const tuple<Args...>& args) {
     os << '[';
     // 需要知道tuple的元素index，用sizeof...(Args)获得元素个数
     print_tuple<, sizeof...(Args), Args...>::print(os, args);
     return os << ']';
 }

 int main() {
     cout << make_tuple(7.5, string("hello"), bitset<>(), );    // print "[7.5, hello, 0000000101111001, 42]"
     return ;
 }

例二、C++STL 中 tuple 的实现（类的递归继承）

template <typename... Values> class tuple;
template <> class tuple<> { };

template <typename Head, typename... Tail>
class tuple<Head, Tail...> : private tuple <Tail...> {
    typedef tuple<Tail...> inherited;
public:
    tuple() { }
    tuple(Head v, Tail... vtail) : m_head(v), inherited(vtail...) { }    // 调用base ctor
    ...
protected:
    Head m_head;
};

例三、模拟 tuple（类的递归复合）

template <typename... Values> class tup;
template <> class tup<> { };

template <typename Head, typename... Tail>
class tup<Head, Tail...> {
    typedef tup<Tail...> composited;
public:
    tup() { }
    tup(Head v, Tail... vtail) : m_head(v), m_tail(vtail...) { }    // 递归复合
    ...
protected:
    Head m_head;
    composited m_tail;
};

只是这种实现 tuple 的方式内存消耗较大