如何递归元组？

Question

我正在尝试制作一个可变参数模板容器，用于存储元素向量的元组。这个容器的要点是所有向量中的元素都是相关的，我想在以后保持这种相关性，但这对于计算来说不是必需的。想象一下，如果你愿意的话，一个 vector_3 和一个某种类型的 ref_id。

容器只会将向量统一变异在一起。所以我理解的部分看起来像这样：

template<typename ...Elems>
class container
{
    std::tuple<std::vector<Elems>...> data_;

public:
    template<typename I>
    const typename std::tuple_element<I, data_type>::type &nth_index() const
    { return std::get<I>(data_); }
};

我正在努力使用插入方法。我的想法是这样的：

void push_back(std::tuple<Elems...> &values)
{
    std::tuple<std::back_insert_iterator<std::vector<Elems>>...> inserters;
}

但我不知道如何初始化这个“插入器”元组。我一直在 stackoverflow 上查看各种递归模板示例，但我无法将其全部记在脑海中足够长的时间来理解它。

我假设如果我有这样一个元组，我可以使用简单的赋值：

inserters = values;

我还想为所有返回值元组的数组编写一个访问器：

std::tuple<Elems &...> operator[](const size_t index)
{
     ...
}

但我又不知道如何初始化这个元组。

我不可能是唯一一个想要这样做的人，而且我找不到学习它的好资源。同时，我正在尝试消化 0x 的原始可变参数模板提案。洞察力将不胜感激。我受到 MSVC 2012 实施的限制。

Answer 1

#include <vector>
#include <tuple>
#include <cstddef>
#include <utility>

template <typename... Elems>
class container
{
    using data_type = std::tuple<std::vector<Elems>...>;

    data_type data_;

public:    
    template <std::size_t I>
    const typename std::tuple_element<I, data_type>::type& nth_index() const
    { return std::get<I>(data_); }

    void push_back(const std::tuple<Elems...>& values)
    {
        return push_back(std::make_index_sequence<sizeof...(Elems)>{}, values);
    }    

    std::tuple<Elems&...> operator[](std::size_t index)
    {
        return get_elems(std::make_index_sequence<sizeof...(Elems)>{}, index);
    }

private:
    template <std::size_t... Is>
    void push_back(std::index_sequence<Is...>, const std::tuple<Elems...>& values)
    {
        using expand = int[];
        static_cast<void>(expand{ 0, (std::get<Is>(data_).push_back(std::get<Is>(values)), 0)... });
    }

    template <std::size_t... Is>
    std::tuple<Elems&...> get_elems(std::index_sequence<Is...>, std::size_t index)
    {
        return std::forward_as_tuple(std::get<Is>(data_)[index]...);
    }
};

DEMO

Answer 2

具有 SFINAE 和类型特征的 C++11 解决方案：

template<typename ...Elems>
class container {
  std::tuple<std::vector<Elems>...> data_;

  template<std::size_t N>
  typename std::enable_if<(N <std::tuple_size<decltype(data_)>::value), int>::type
  push_back_impl(std::tuple<Elems...> const &values) {
    std::get<N>(data_).push_back(std::get<N>(values));
    return push_back_impl<N + 1>(values);
  }

  template<std::size_t N>
  typename std::enable_if<(N == std::tuple_size<decltype(data_)>::value), int>::type
  push_back_impl(std::tuple<Elems...> const &values) {
    return 0;
  }

public:

  void push_back(std::tuple<Elems...> const &values) {
     push_back_impl<0>(values);
  }

};

Live Demo

至于下标运算符，您需要在 SO answer 中找到一些额外的机制：

template <size_t ...I>
struct index_sequence {};

template <size_t N, size_t ...I>
struct make_index_sequence : public make_index_sequence<N - 1, N - 1, I...> {};

template <size_t ...I>
struct make_index_sequence<0, I...> : public index_sequence<I...> {};

template<typename ...Elems>
class container {
  std::tuple<std::vector<Elems>...> data_;

  template<size_t ...I>
  std::tuple<Elems&...> access_impl(std::size_t const idx, index_sequence<I...>) {
    return std::tie(std::get<I>(data_)[idx]...);
  }

public:

  std::tuple<Elems&...> operator[](std::size_t const idx) {
    return access_impl(idx, make_index_sequence<sizeof...(Elems)>());
  }
};

Live Demo