1

我想将传递给可变参数模板的模板参数填充到一个固定长度的数组中。为此，我编写了以下辅助函数模板

template<typename ForwardIterator, typename T>
void fill(ForwardIterator i) { }

template<typename ForwardIterator, typename T, T head, T... tail>
void fill(ForwardIterator i) {
  *i = head;
  fill<ForwardIterator, T, tail...>(++i);
}

以下类模板

template<typename T, T... args>
struct params_to_array;

template<typename T, T last>
struct params_to_array<T, last> {
  static const std::size_t SIZE = 1;
  typedef std::array<T, SIZE> array_type;

  static const array_type params;

private:
  void init_params() {
    array_type result;
    fill<typename array_type::iterator, T, head, tail...>(result.begin());
    return result;
  }
};

template<typename T, T head, T... tail>
struct params_to_array<T, head, tail...> {
  static const std::size_t SIZE = params_to_array<T, tail...>::SIZE + 1;
  typedef std::array<T, SIZE> array_type;

  static const array_type params;

private:
  void init_params() {
    array_type result;
    fill<typename array_type::iterator, T, last>(result.begin());
    return result;
  }
};

并通过初始化静态常量

template<typename T, T last>
const typename param_to_array<T, last>::array_type
param_to_array<T, last>::params =
  param_to_array<T, last>::init_params();

和

template<typename T, T head, T... tail>
const typename param_to_array<T, head, tail...>::array_type
param_to_array<T, head, tail...>::params =
  param_to_array<T, head, tail...>::init_params();

现在数组

param_to_array<int, 1, 3, 4>::params

是 a并且std::array<int, 3>包含值1和。我认为必须有一种更简单的方法来实现这种行为。有什么建议么？34

编辑：正如诺亚罗伯茨在他的回答中建议的那样，我修改了我的程序，如下所示：我写了一个新的结构来计算参数列表中的元素：

template<typename T, T... args>
struct count;

template<typename T, T head, T... tail>
struct count<T, head, tail...> {
  static const std::size_t value = count<T, tail...>::value + 1;
};

template<typename T, T last>
stuct count<T, last> {
  static const std::size_t value = 1;
};

并编写了以下函数

template<typename T, T... args>
std::array<T, count<T, args...>::value>
params_to_array() {
  std::array<T, count<T, args...>::value> result;
  fill<typename std::array<T, count<T, args...>::value>::iterator,
       T, args...>(result.begin());
  return result;
}

现在我得到了

params_to_array<int, 10, 20, 30>()

astd::array<int, 3>与内容10，20和30。有什么进一步的建议吗？

4

2 回答 2

2

无需手动计算参数包中的类型数量，这就是sizeof...运算符的用途。另外，我将迭代器类型设为可fill()推导，无需明确指定它：

template<typename T, typename FwdIt>
void fill(FwdIt it) { }

template<typename T, T head, T... tail, typename FwdIt>
void fill(FwdIt it) {
    *it = head;
    fill<T, tail...>(++it);
}

template<class T, T... args> 
std::array<T, sizeof...(args)> params_to_array() {
    std::array<T, sizeof...(args)> a;
    fill<T, args...>(a.begin());
    return a;
};

然而，参数包在初始化列表上下文中也是可扩展的，这使得fill()冗余：

template<class T, T... args> 
std::array<T, sizeof...(args)> params_to_array() {
    std::array<T, sizeof...(args)> a = {{args...}};
    return a;
};
于 2010-05-18T19:50:00.290 回答
1

我可以看到 param_to_array 中对 terminus 进行专门化的唯一原因是这一行：

static const std::size_t SIZE = params_to_array<T, tail...>::SIZE + 1;

由于您的 params_to_array 元函数创建了数组，尽管您最终将实例化大小为 N、N-1、....、1 的数组。因此，我认为您的对象可以使用组合和单一责任规则的一些帮助。创建另一个可以对参数列表中的元素进行计数的元函数并使用它来代替此方法。然后，您至少可以摆脱 params_to_array 中的这种递归。

于 2010-05-17T16:15:26.683 回答