パラメータパック(C++11以上)

template<class ... Types> struct Tuple {};
Tuple<> t0;           // OK、 Types は引数を持ちません。
Tuple<int> t1;        // OK、 Types は1個の引数 (int) を持ちます。
Tuple<int, float> t2; // OK、 Types は2個の引数 (int, float) を持ちます。
Tuple<0> error;       // エラー、 0 は型ではありません。

template<class ... Types> void f(Types ... args);
f();       // OK、 Types は引数を持ちません。
f(1);      // OK、 Types は1個の引数 (int) を持ちます。
f(2, 1.0); // OK、 Types は2個の引数 (int, double) を持ちます。

template<typename... Ts, typename U> struct Invalid; // エラー、 Ts は最後でなければなりません。
 
template<typename ...Ts, typename U, typename=void>
void valid(U, Ts...);     // OK、 U は推定できます。
// void valid(Ts..., U);  // この場合はエラーです。 Ts... はこの位置では非推定文脈です。
 
valid(1.0, 1, 2, 3);      // OK、 U は double と推定され、 Ts は {int,int,int} と推定されます。

template<class ...Us> void f(Us... pargs) {}
template<class ...Ts> void g(Ts... args) {
    f(&args...); // 「&args...」がパック展開です。
                 // 「&args」がパターンです。
 
g(1, 0.2, "a"); // Ts... args は int E1, double E2, const char* E3 に展開され、
                // &args... は &E1, &E2, &E3 に展開され、
                // Us... pargs は int* E1, double* E2, const char** E3 に展開されます。

template<typename...> struct Tuple {};
template<typename T1, typename T2> struct Pair {};
 
template<class ...Args1> struct zip {
    template<class ...Args2> struct with {
        typedef Tuple<Pair<Args1, Args2>...> type;
        // 「Pair<Args1, Args2>...」がパック展開です。
        // 「Pair<Args1, Args2>」がパターンです。
    };
};
 
typedef zip<short, int>::with<unsigned short, unsigned>::type T1;
// Pair<Args1, Args2>... は
// Pair<short, unsigned short>, Pair<int, unsigned int> に展開されます。
// T1 は Tuple<Pair<short, unsigned short>, Pair<int, unsigned>> です。
 
typedef zip<short>::with<unsigned short, unsigned>::type T2;
// エラー、パック展開に長さの異なるパラメータパックが含まれます。

template<class ...Args>
void g(Args... args) {
    f(const_cast<const Args*>(&args)...); 
    // 「const_cast<const Args*>(&args)」がパターンです。
    // 2つのパック (Args と args) が同時に展開されます。
 
    f(h(args...) + args...); // ネストしたパック展開。
    // 内側のパック展開は args... です。 まずこれが例えば E1, E2, E3 のように展開されます。
    // 外側のパック展開は h(E1, E2, E3) + args... です。 次にこれが例えば
    // h(E1,E2,E3) + E1, h(E1,E2,E3) + E2, h(E1,E2,E3) + E3 のように展開されます。
}

f(&args...); // f(&E1, &E2, &E3) に展開されます。
f(n, ++args...); // f(n, ++E1, ++E2, ++E3) に展開されます。
f(++args..., n); // f(++E1, ++E2, ++E3, n) に展開されます。
f(const_cast<const Args*>(&args)...);
// f(const_cast<const T1*>(&E1), const_cast<const T2*>(&E2), const_cast<const T3*>(&E3)) に展開されます。
f(h(args...) + args...);
// f(h(E1,E2,E3) + E1, h(E1,E2,E3) + E2, h(E1,E2,E3) + E3) に展開されます。

Class c1(&args...);             // Class::Class(&E1, &E2, &E3) を呼びます。
Class c2 = Class(n, ++args...); // Class::Class(n, ++E1, ++E2, ++E3) を呼びます。
::new((void *)p) U(std::forward<Args>(args)...) // std::allocator::allocate

template<typename... Ts> void func(Ts... args){
    const int size = sizeof...(args) + 2;
    int res[size] = {1,args...,2};
    // 初期化子リストは評価順序を保証するため、
    // パックの各要素に対して順番に関数を呼ぶために使用できます。
    int dummy[sizeof...(Ts)] = { (std::cout << args, 0)... };
}

template<class A, class B, class...C> void func(A arg1, B arg2, C...arg3)
{
    container<A,B,C...> t1;  // container<A,B,E1,E2,E3> に展開されます。
    container<C...,A,B> t2;  // container<E1,E2,E3,A,B> に展開されます。
    container<A,C...,B> t3;  // container<A,E1,E2,E3,B> に展開されます。
}

template<typename ...Ts> void f(Ts...) {}
f('a', 1);  // Ts... は char, int に展開されます。
f(0.1);     // Ts... は double に展開されます。
 
template<typename ...Ts, int... N> void g(Ts (&...arr)[N]) {}
int n[1];
g<const char, int>("a", n); // Ts (&...arr)[N] は
                            // const char (&)[2], int (&)[1] に展開されます。

template<typename... T> struct value_holder
{
    template<T... Values> // 非型テンプレート仮引数リストに展開されます 
    struct apply { };     // (例えば <int, char, int(&)[5]>)。
};

template<class... Mixins>
class X : public Mixins... {
 public:
    X(const Mixins&... mixins) : Mixins(mixins)... { }
};

template<class ...Args>
void f(Args... args) {
    auto lm = [&, args...] { return g(args...); };
    lm();
}

template<class... Types>
struct count {
    static const std::size_t value = sizeof...(Types);
};