Converting one parameter pack into another? - c++11

Question

I would like to convert a parameter pack of iterator types into the corresponding parameter pack of references. This is what I've got so far:
template <class Iterator, class... Iterators>
class cast_iterators_to_references
{
using head_reference_type = std::iterator_traits<Iterator>::reference
// TODO
//using type = ;
};
Where do I take it from here?
The reason I'm doing this is to create a "view" object. It contains a tuple of iterators to the containers it's referencing. I'd like to have a method that returns a tuple of the elements at some index so that I can create a custom iterator for it, create begin and end methods, and use it in a range-based for statement.
Here's how it could be used:
template<class Iterators...>
tuple_iterator
{
public:
using tuple_type = std::tuple<Iterators...>;
using references = cast_iterators_to_references<Iterators...>;
using tuple_element_type = std::tuple<references>;
// ... construct from tuple, copy/move constructors, copy/move assignment etc.
tuple_element_type operator[](size_t index)
{
tuple_element_type element;
for (size_t i = 0; i < sizeof...(Iterators); i++)
std::get<i>(element) = std::get<i>(data_)[offset_ + index];
return element;
}
// ... increment, decrement operators etc.
private:
tuple_type data_;
size_t offset_;
}

Answer 1

Parameter packs are not first-class, so they are a bit fiddly to handle.
A first stab at the cast_iterators_to_references metafunction could be this :
// Not defined, used to wrap a pack into a type
template <class...> struct pack;
template <class... Iterators>
using cast_iterators_to_references = pack<
typename std::iterator_traits<Iterators>::reference...
>;
But then you need helper classes to unpack the pack via pattern-matching :
template <class> unpack_to_tuple;
template <class... Ts> unpack_to_tuple<pack<Ts...>> {
using type = std::tuple<Ts...>;
};
// In your class
using references = cast_iterators_to_references<Iterators...>;
using tuple_element_type = typename unpack_to_tuple<references>::type;
So you're probably better off using the parameter pack directly :
using tuple_element_type = std::tuple<
typename std::iterator_traits<Iterators>::reference...
>;
Your operator[] can be written as follows :
template <std::size_t... Idx>
auto access(size_t index, std::index_sequence<Idx...>) {
return std::tie(std::get<Idx>(data_)[index + offset_]...);
}
tuple_element_type operator[](size_t index)
{
return access(index, std::index_sequence_for<Iterators...>{});
}