c++ - 如何创建具有指定数量(相同类型)的元素的boost::tuple？

假设我具有以下类定义:

template <unsigned int N>
class foo
{
    boost::tuples::tuple<...> bar;
};

给定编译时常量N，我想将bar的类型扩展为一个包含指定类型的N元素的元组。也就是说，foo<2>::bar的类型将为boost::tuples::tuple<T, T>。我猜我可以为此使用Boost.MPL，但是我还没有弄清楚确切的顺序。我想我可以做到:

template <typename T, int N>
struct type_repeater
{
    typedef typename boost::mpl::fold<
        boost::mpl::range_c<T, 0, N>,
        boost::mpl::vector<>,
        boost::mpl::push_back<_1, T>
    >::type type;
};

因此，例如type_repeater<T, 2>::type将等同于boost::mpl::vector<T, T>。我只是不确定如何/是否可以像我想要的那样使用该类型列表并将其注入(inject)到元组的参数列表中。这可能吗？

最佳答案

尽管这对于可变参数模板和std::tuple完全可行，但是我认为最好的解决方案是仅使用std::array。如果只需要一个包含N个T实例的容器，则std::array签名已经是template <typename T, std::size_t N> class array。我认为这完全符合您的需求。

话虽如此，如果您出于某种原因真的想要std::tuple，可以这样操作:

#include <tuple>

/* Forward declaration. */
template <std::size_t N, typename T>
class Tuple;

/* Convenience type alias. */
template <std::size_t N, typename T>
using TTuple = typename Tuple<N, T>::type;

/* Base case. */
template <typename T>
class Tuple<0, T> {
  public:

  using type = std::tuple<>;

}; // Tuple<0>

/* Recursive case. */
template <std::size_t N, typename T>
class Tuple {
  public:

  /* Note the use of std::declval<> here. */
  using type = decltype(std::tuple_cat(std::declval<std::tuple<T>>(),
                                       std::declval<TTuple<N - 1, T>>()));

};  // Tuple<N, T>

/* std::declval<> is necessary to support non default constructable classes. */
class NoDefault {
  public:

  NoDefault() = delete;

};  // Foo

/* Sample use. */
static_assert(std::is_same<TTuple<2, NoDefault>,
                           std::tuple<NoDefault, NoDefault>>::value, "");

int main() {}

注意:如果您无权访问C++ 11但可以访问boost，那么boost::array和boost::tuples::tuple可以代替std::array和std::tuple很好。

关于c++ - 如何创建具有指定数量(相同类型)的元素的boost::tuple？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/20711721/