将可变参数模板参数转换为其他类型 [英] Transform variadic template parameters to another types

问题描述

如何将类型从可变参数模板参数转换为另一种类型？

How to transform types from variadic template parameters to another type?

例如：

template <typename... T>
struct single
{
   std::tuple<T...> m_single;
};

template <typename... T>
struct sequences
{
   single<T...> get(size_t pos)
   {
       // I don't know how to convert here
       return std::make_tuple(std::get<0>(m_sequences)[pos]... std::get<N>(m_sequences)[pos]);
   }

   template <size_t Idx>
   std::vector<
      typename std::tuple_element<Idx, std::tuple<T...>>::type
      >
   get_sequence()
   {
      return std::get<Idx>(m_sequences);
   }

   std::tuple<T...> m_sequences; // std::tuple<std::vector<T...>> I don't know how to conver here
};

我要这样写：

sequences<int, double, double> seq;
single<int, double, double> sin = seq.get(10);

并且拥有 std :: tuple< std :: vector< int& std :: vector< double>，std :: vector< double>> 并从中获得单一。

And have std::tuple<std::vector<int>, std::vector<double>, std::vector<double>> in struct sequences. And get single from it.

std :: vector< single< T ...>> 对我来说是坏主意，因为我需要一个序列充满，很容易从中复制。

std::vector<single<T...>> is bad idea for me, because i need get one sequence full to and it's easy to copy it from .

有可能吗？

非常感谢。对不起我的英语。

Thank you very much. Sorry for my bad English.

推荐答案

您可以做更多不仅仅是扩展一个可变参数包作为一个简单的列表：一个表达式。因此，您可以将 m_sequences 作为向量的元组，而不是元素的元组：

You can do more than just expand a variadic parameter pack as a plain list: you can expand an expression too. You can therefore have m_sequences be a tuple of vectors rather than a tuple of the elements:

template <typename... T>
struct sequences
{
   std::tuple<std::vector<T>...> m_sequences;
};

您还可以使用参数包来拾取适当的元素：

You can also do nifty tricks with parameter packs to pick the appropriate element from the vector:

template<size_t ... Indices> struct indices_holder
{};

template<size_t index_to_add,typename Indices=indices_holder<> >
struct make_indices_impl;

template<size_t index_to_add,size_t...existing_indices>
struct make_indices_impl<index_to_add,indices_holder<existing_indices...> >
{
    typedef typename make_indices_impl<
        index_to_add-1,
        indices_holder<index_to_add-1,existing_indices...> >::type type;
};

template<size_t... existing_indices>
struct make_indices_impl<0,indices_holder<existing_indices...> >
{
    typedef indices_holder<existing_indices...>  type;
};

template<size_t max_index>
typename make_indices_impl<max_index>::type make_indices()
{
    return typename make_indices_impl<max_index>::type();
}



template <typename... T>
struct sequences
{
    std::tuple<std::vector<T>...> m_sequences;

    template<size_t... Indices>
    std::tuple<T...> get_impl(size_t pos,indices_holder<Indices...>)
    {
        return std::make_tuple(std::get<Indices>(m_sequences)[pos]...);
    }

    std::tuple<T...> get(size_t pos)
    {
        return get_impl(pos,make_indices<sizeof...(T)>());
    }
};

这篇关于将可变参数模板参数转换为其他类型的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！