【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<16>(377), 42);    // print "7.5 hello 0000000101111001 42"
    return 0;
}

如果同时存在函数

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
", pi, "This is pi", 3.1415926);    // print "[0x21fcc20] This is pi = 3.14159"
    return 0;
}

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 + 1 == MAX ? "" : ", ");
        print_tuple<IDX + 1, 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<0, sizeof...(Args), Args...>::print(os, args);
    return os << ']';
}

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

例二、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 的方式内存消耗较大