乐趣区

关于c++:C模板参数包

jiezi

1. 简介

模板参数包是承受零个或多个模板参数（非类型、类型或模板）的模板参数。
函数参数包是承受零个或多个函数参数的函数参数。

2. 语法

(1) 非类型模板参数包：

Type... Args

此处 Type 为具体的类型，如 int.

(2) 类型模板参数包：

typename... Types

(3) 模板模板参数包：（即模板形参是另一个模板）

template <parameter-list> typename... Types

(4) 函数参数包：

Types... Args

(5) 参数包扩大：

pattern...

将 pattern 扩大为以逗号分隔的列表（蕴含 0 或多个模式）. 其中，pattern 必须蕴含至多一个参数包.

在类模板中，模板参数包需是最初一个模板形参. 而在函数模板中则不用（指的是在模板形参列表中的地位，而不是函数形参列表），只有可能从函数实参列表推断出参数包即可.

template<typename... Ts, typename U> struct Invalid; // Error: Ts.. not at the end
 
template<typename... Ts, typename U, typename=void>
void valid(U, Ts...);     // OK: can deduce U
// void valid(Ts..., U);  // Can't be used: Ts... is a non-deduced context in this position

从上例中能够看出，即便是在函数模板中，参数包仍须要是函数形参列表的最初一个参数.
简略起见，尽量将参数包放在最初.

例子 1：

template<typename... Ts>    // (2)
void f(Ts...) {}            // (4)
template<typename... Ts, int... N>        // (2),(1)
void g(Ts (&...arr)[N]) {}                // (4)

int n[1];
g<const char, int>("a", n); // Ts (&...arr)[N] expands to 
                            // const char (&)[2], int(&)[1]

留神：不容许应用 Ts (&...)[N]，因为 C++11 语法要求圆括号括起的 ... 须要有一个名字.

例子 2：

#include <iostream>

void g(int& i)
{std::cout << "lvalue reference:" << i << '\n';}

void g(int&& i)
{std::cout << "rvalue reference:" << i << '\n';}

template <typename T>
void f(T&& arg)
{g(std::forward<T>(arg));
}

template <typename T, typename... Ts>
void f(T&& arg0, Ts&&... args)
{g(std::forward<T>(arg0));
    f(std::forward<Ts>(args)...);    // pattern 为 std::forward<Ts>(args)
}

int main()
{
    int a = 1, b = 2, c = 3;
    f(a, b, c);
    std::cout << "----------------------\n";
    f(1, 2, 3);
}
lvalue reference: 1
lvalue reference: 2
lvalue reference: 3
----------------------
rvalue reference: 1
rvalue reference: 2
rvalue reference: 3

此处联合完满转发应用.

例子 3：

#include <iostream>

void myPrintf(const char* fmt)
{std::cout << fmt;}

template <typename T, typename... Ts>
void myPrintf(const char* fmt, T value, Ts... args)
{for (; *fmt != '\0'; fmt++)
    {if (*fmt == '%')
        {
            std::cout << value;

            myPrintf(fmt+1, args...);
            return;
        }

        std::cout << *fmt;
    }
}

int main()
{myPrintf("Hello, I'm %, % yeas old.","gzming", 20);
}
Hello, I'm gzming, 20 yeas old.

3. 参数包扩大

  • 当 pattern 中蕴含多个参数包时，这些参数包的长度应该统一.

    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> is the pattern};
};

typedef zip<short, int>::with<unsigned short, unsigned>::type T1;

  • 当参数包嵌套时，内层的参数包先扩大，而后再和外层的参数包一起扩大.

    template<class... Args>
void g(Args... args) {
  /*
  inner pack expansion is "args...", it is expanded first
  outer pack expansion is h(E1, E2, E3) + args..., it is expanded
  second (as h(E1,E2,E3) + E1, h(E1,E2,E3) + E2, h(E1,E2,E3) + E3)
  */
  f(h(args...) + args...);
}

4. 能够应用参数包扩大的中央

  • 函数实参列表 

    f(&args...);
f(++args..., n);

// f(const_cast<const E1*>(&X1), const_cast<const E2*>(&X2), const_cast<const E3*>(&X3))
f(const_cast<const Args*>(&args)...);

  • 圆括号初始化器 

    Class c1(&args...);

  • 花括号初始化器 

    template<typename... Ts> void func(Ts... args) {const int size = sizeof...(args) + 2;
  int res[size] = {1,args...,2};
}

    sizeof... 运算符返回参数包的大小.

  • 模板实参列表 

    template<class A, class B, class...C>
void func(A arg1, B arg2, C...arg3)
{
  container<A, B, C...> t1; 
  container<C..., A, B> t2; 
  container<A, C..., B> t3;
}

  • 函数形参列表 

    template<typename ...Ts> void f(Ts...) {}

  • 模板形参列表 

    template<typename... T>
struct value_holder
{
  template<T... Values> // expands to a non-type template parameter list,
  struct apply {};     // such as <int, char, int(&)[5]>
};

  • 基类列表、成员初始化列表 

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

  • Lambda 捕捉 

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

  • sizeof... 运算符 

    template<class... Types>
struct count {static const std::size_t n = sizeof...(Types);
};
退出移动版