如何使用 C++11 可变参数模板来定义由向量元组支持的元组向量？

Question

假设我有一堆向量：

vector<int> v1;
vector<double> v2;
vector<int> v3;

长度相同。现在，对于每个索引 i，我希望能够将 (v1[i], v2[i], v3[i]) 视为一个元组，并可能传递它。事实上，我想要一个元组向量而不是向量元组，我可以使用它来完成上述操作。 （在 C 语言中，我可能会说结构数组而不是数组结构）。我不想影响任何数据重新排序（想想：真的很长的向量），即新向量由我传入的单个向量支持。让我们。

现在，我希望我编写的类（称其为 ToVBackedVoT，因为没有更好的名称）支持任意选择向量来支持它（不仅仅是 3，不是 int、double 和 int，不是每个都只是标量)。我希望元组向量是可变的，并且不希望在构造/分配时复制。

如果我理解正确，可变参数模板和 C++11 中的新 std::tuple 类型是执行此操作的方法（假设我不想要无类型的 void* 数组等）。然而，我几乎不认识他们，也从未与他们合作过。你能帮我勾勒出这样一个班级的样子吗？或者如何，给定

template <typename ... Ts>

我可以表达类似“模板参数列表是用这种类型的元素向量替换原始模板参数中的每个类型名”之类的东西？

注意：我想我以后可能还希望能够将其他向量连接到支持向量，使 ToVBackedVoT<int, double, int> 的实例成为 ToVBackedVoT<int, double, int, unsigned int> 的实例。因此，在回答时请记住这一点。不过，这并不重要。

Answer 1

一个想法是将 storage 保持在“数组结构”样式中，以向量的形式在只有字段的一个子集用于特定任务时获得良好的性能。然后，对于需要一组不同字段的每种任务，您可以围绕这些向量中的 一些 编写一个轻量级包装器，为您提供一个类似于 std::vector 支持的漂亮的随机访问迭代器接口。

关于可变参数模板的语法，这就是包装类（还没有任何迭代器）的样子：

template<class ...Ts> // Element types
class WrapMultiVector
{
    // references to vectors in a TUPLE
    std::tuple<std::vector<Ts>&...> m_vectors;

public:
    // references to vectors in multiple arguments
    WrapMultiVector(std::vector<Ts> & ...vectors)
        : m_vectors(vectors...)    // construct tuple from multiple args.
    {}
};

要构造这样一个模板类，通常最好有一个可用的模板类型扣除辅助函数（类似于std 中的那些make_{pair|tuple|...} 函数）：

template<class ...Ts> // Element types
WrapMultiVector<Ts...> makeWrapper(std::vector<Ts> & ...vectors) {
    return WrapMultiVector<Ts...>(vectors...);
}

您已经看到了不同类型的“解包”类型列表。

添加适合您的应用程序的迭代器（您特别要求随机访问迭代器）并不容易。开始可以是只转发迭代器，您可以将其扩展到随机访问迭代器。

以下迭代器类能够使用元素迭代器的元组构造，递增和取消引用以获得元素元组references（对于读写访问很重要）。

class iterator {
    std::tuple<typename std::vector<Ts>::iterator...> m_elemIterators;

public:
    iterator(std::tuple<typename std::vector<Ts>::iterator...> elemIterators) 
        : m_elemIterators(elemIterators)
    {}

    bool operator==(const iterator &o) const {
        return std::get<0>(m_elemIterators) == std::get<0>(o.m_elemIterators);
    }
    bool operator!=(const iterator &o) const {
        return std::get<0>(m_elemIterators) != std::get<0>(o.m_elemIterators);
    }

    iterator& operator ++() {
        tupleIncrement(m_elemIterators);
        return *this;
    }
    iterator operator ++(int) {
        iterator old = *this;
        tupleIncrement(m_elemIterators);
        return old;
    }

    std::tuple<Ts&...> operator*() {
        return getElements(IndexList());
    }

private:
    template<size_t ...Is>
    std::tuple<Ts&...> getElements(index_list<Is...>) {
        return std::tie(*std::get<Is>(m_elemIterators)...);
    }
};

出于演示目的，此代码中有两种不同的模式，它们“迭代”一个元组，以便应用某些操作或构造一个新的元组，其中包含要调用的某些表达式每个元素。我同时使用了这两种方法来展示替代方案；你也可以只使用第二种方法。

1. tupleIncrement: 你可以使用一个辅助函数，它使用元编程来索引单个条目并将索引前进一个，然后调用递归函数，直到索引位于元组的末尾（然后有一个使用 SFINAE 触发的特殊情况实现）。该函数是在类之外而不是在上面定义的；这是它的代码：

   template<std::size_t I = 0, typename ...Ts>
   inline typename std::enable_if<I == sizeof...(Ts), void>::type
   tupleIncrement(std::tuple<Ts...> &tup)
   { }
   template<std::size_t I = 0, typename ...Ts>
   inline typename std::enable_if<I < sizeof...(Ts), void>::type
   tupleIncrement(std::tuple<Ts...> &tup)
   {
       ++std::get<I>(tup); 
       tupleIncrement<I + 1, Ts...>(tup);
   }
   

   在operator* 的情况下，此方法不能用于分配引用元组，因为这样的元组 必须立即使用引用进行初始化，而这在此方法中是不可能的。所以operator*需要别的东西：

2. getElements：这个版本使用了一个索引列表（https://stackoverflow.com/a/15036110/592323），它也被扩展了，然后你可以使用std::get和索引列表来扩展完整的表达式。调用函数时的IndexList 实例化了一个适当的索引列表，该索引列表仅在模板类型推导时需要，以获取那些Is...。类型可以在包装类中定义：

   // list of indices
   typedef decltype(index_range<0, sizeof...(Ts)>()) IndexList;
   

更完整的代码和一个小例子可以在这里找到：http://ideone.com/O3CPTq

未解决的问题是：

• 如果向量的大小不同，则代码会失败。最好检查所有“结束”迭代器是否相等；如果一个迭代器“结束”，我们也“结束”；但这需要比operator== 和operator!= 更多的逻辑，除非可以“伪造”它；这意味着只要 any 运算符不相等，operator!= 就会返回 false。

• 解决方案不是 const 正确的，例如没有const_iterator。

• 无法进行追加、插入等操作。包装类可以添加一些insert 或和/或push_back 函数以使其与std::vector 类似地工作。如果您的目标是在语法上与元组向量兼容，请重新实现 std::vector 中的所有相关函数。

• 没有足够的测试；）

Answer 2

所有可变参数模板杂耍的替代方法是为此目的使用boost::zip_iterator。例如（未经测试）：

std::vector<int> ia;
std::vector<double> d;
std::vector<int> ib;

std::for_each(
  boost::make_zip_iterator(
    boost::make_tuple(ia.begin(), d.begin(), ib.begin())
    ),
  boost::make_zip_iterator(
    boost::make_tuple(ia.end(), d.end(), ib.end())
    ),
  handle_each()
  );

您的处理程序的位置如下：

struct handle_each :
  public std::unary_function<const boost::tuple<const int&, const double&, const int&>&, void>
{
  void operator()(const boost::tuple<const int&, const double&, const int&>& t) const
  {
    // Now you have a tuple of the three values across the vector...
  }
};

如您所见，扩展它以支持任意向量集非常简单。

Answer 3

根据提问者对如何使用它的说明（采用元组的代码），我将提出这个建议。

//give the i'th element of each vector
template<typename... Ts>
inline tuple<Ts&...> ith(size_t i, vector<Ts>&... vs){
    return std::tie(vs[i]...);
}

---

有一个提议允许将参数包保存为类的成员 (N3728)。使用它，这里有一些未经测试和不可测试的代码。

template<typename... Types>
class View{
private:
    vector<Types>&... inner;

public:

    typedef tuple<Types&...> reference;

    View(vector<Types>&... t): inner(t...) {}

    //return smallest size
    size_t size() const{
        //not sure if ... works with initializer lists
        return min({inner.size()...});
    }

    reference operator[](size_t i){
        return std::tie(inner[i]...);
    }
};

和迭代：

public:
    iterator begin(){
        return iterator(inner.begin()...);
    }
    iterator end(){
        return iterator(inner.end()...);
    }

    //for .begin() and .end(), so that ranged-based for can be used
    class iterator{
        vector<Types>::iterator... ps;
        iterator(vector<Types>::iterator... its):ps(its){}
        friend View;

    public:

        //pre:
        iterator operator++(){
            //not sure if this is allowed.
            ++ps...;
            //use this if not:
            //  template<typename...Types> void dummy(Types... args){} //global
            //  dummy(++ps...);
            return *this;
        }
        iterator& operator--();
        //post:
        iterator operator++(int);
        iterator operator--(int);
        //dereference:
        reference operator*()const{
            return std::tie(*ps...);
        }
        //random access:
        iterator operator+(size_t i) const;
        iterator operator-(size_t i) const;
        //need to be able to check end
        bool operator==(iterator other) const{
            return std::make_tuple(ps...) == std::make_tuple(other.ps...);
        }
        bool operator!=(iterator other) const{
            return std::make_tuple(ps...) != std::make_tuple(other.ps...);
        }

    };

Answer 4

你可以使用类似的东西：

#if 1 // Not available in C++11, so write our own

// class used to be able to use std::get<Is>(tuple)...
template<int... Is>
struct index_sequence { };

// generator of index_sequence<Is>
template<int N, int... Is>
struct make_index_sequence : make_index_sequence<N - 1, N - 1, Is...> { };

template<int... Is>
struct make_index_sequence<0, Is...> : index_sequence<Is...> { };

#endif

// The 'converting' class
// Note that it doesn't check that vector size are equal...
template<typename ...Ts>
class ToVBackedVoT
{
public:
    explicit ToVBackedVoT(std::vector<Ts>&... vectors) : data(vectors...) {}

    std::tuple<const Ts&...> operator [] (unsigned int index) const
    {
        return at(index, make_index_sequence<sizeof...(Ts)>());
    }
    std::tuple<Ts&...> operator [] (unsigned int index)
    {
        return at(index, make_index_sequence<sizeof...(Ts)>());
    }

private:
    template <int... Is>
    std::tuple<const Ts&...> at(unsigned int index, index_sequence<Is...>) const
    {
        return std::tie(std::get<Is>(data)[index]...);
    }

    template <int... Is>
    std::tuple<Ts&...> at(unsigned int index, index_sequence<Is...>)
    {
        return std::tie(std::get<Is>(data)[index]...);
    }

private:
    std::tuple<std::vector<Ts>&...> data;
};

要进行迭代，请创建一个类似于https://stackoverflow.com/a/20272955/2684539 中的“IndexIterator”

要连接其他向量，您必须创建另一个 ToVBackedVoT，就像 std::tuple_cat 为 std::tuple 所做的那样

Answer 5

转换为向量的 std::tuple (vector::iterators)：

#include <iostream>
#include <vector>

// identity
// ========

struct identity
{
    template <typename T>
    struct apply {
        typedef T type;
    };
};

// concat_operation
// ================

template <typename Operator, typename ...> struct concat_operation;

template <
    typename Operator,
    typename ...Types,
    typename T>
struct concat_operation<Operator, std::tuple<Types...>, T>
{
    private:
    typedef typename Operator::template apply<T>::type concat_type;
    public:
    typedef std::tuple<Types..., concat_type> type;
};

template <
    typename Operator,
    typename ...Types,
    typename T,
    typename ...U>
struct concat_operation<Operator, std::tuple<Types...>, T, U...>
{
    private:
    typedef typename Operator::template apply<T>::type concat_type;
    public:
    typedef typename concat_operation<
        Operator,
        std::tuple<Types..., concat_type>,
        U...>
    ::type type;
};

template <
    typename Operator,
    typename T,
    typename ...U>
struct concat_operation<Operator, T, U...>
{
    private:
    typedef typename Operator::template apply<T>::type concat_type;
    public:
    typedef typename concat_operation<
        Operator,
        std::tuple<concat_type>,
        U...>
    ::type type;
};


// ToVectors (ToVBackedVoT)
// =========

template <typename ...T>
struct ToVectors
{
    private:
    struct to_vector {
        template <typename V>
        struct apply {
            typedef typename std::vector<V> type;
        };
    };

    public:
    typedef typename concat_operation<to_vector, T...>::type type;
};

// ToIterators
// ===========

template <typename ...T>
struct ToIterators;

template <typename ...T>
struct ToIterators<std::tuple<T...>>
{
    private:
    struct to_iterator {
        template <typename V>
        struct apply {
            typedef typename V::iterator type;
        };
    };

    public:
    typedef typename concat_operation<to_iterator, T...>::type type;
};


int main() {
    typedef ToVectors<int, double, float>::type Vectors;
    typedef ToVectors<Vectors, int, char, bool>::type MoreVectors;
    typedef ToIterators<Vectors>::type Iterators;

    // LOG_TYPE(Vectors);
    // std::tuple<
    //     std::vector<int, std::allocator<int> >,
    //     std::vector<double, std::allocator<double> >,
    //     std::vector<float, std::allocator<float> > >

    // LOG_TYPE(Iterators);
    // std::tuple<
    //     __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >,
    //     __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double> > >,
    //     __gnu_cxx::__normal_iterator<float*, std::vector<float, std::allocator<float> > > >
}

Answer 6

作为类似于boost::zip_iterator 的替代方案，我编写了一个zip 函数，其界面非常简单：

vector<int> v1;
vector<double> v2;
vector<int> v3;

auto vec_of_tuples = zip(v1, v2, v3);

例如，遍历这些元组：

for (auto tuple : zip(v1, v2, v3)) {
    int x1; double x2; int x3;
    std::tie(x1, x2, x3) = tuple;
    //...
}

这里，zip() 接受任意数量的任意类型的范围。它返回一个适配器，可以看作是对源自包装范围的元素元组的惰性求值范围。

适配器是我的Haskell-style functional library "fn" 的一部分，并使用可变参数模板实现。

目前由于库的设计原因，它不支持通过适配器修改原始范围的值（它旨在用于非可变范围，如函数式编程）。

简要说明说明如何做到这一点：zip(...) 返回一个实现了begin() 和end() 的适配器对象，返回一个迭代器对象。迭代器将迭代器的元组保存到包装范围。递增迭代器会递增所有包装的迭代器（这是使用索引列表实现的，并将递增表达式解包为一系列表达式：++std::get<I>(iterators)...）。取消引用迭代器将递减所有包装的迭代器并将其传递给std::make_tuple（这也实现为解包表达式*std::get<I>(iterators)...）。

附：它的实现基于来自这个问题的答案的许多想法。