如何生成可变参数包？ [英] How do I generate a variadic parameter pack?

问题描述

给定一个不相关的输入，是否可以生成一个非类型的参数包？我的意思是，我想转换这个：

Is it possible to generate a non-type parameter pack given an unrelated input? What I mean is, I would like like to turn this:

template <typename D, size_t... Offsets> struct VecGeneric;
template <typename N, size_t C> struct VecGenericData;

template <typename N, size_t D> struct TVecN;
template <typename N> struct TVecN<N,2> : public VecGeneric<VecGenericData<N,2>,0,1>           { };
template <typename N> struct TVecN<N,3> : public VecGeneric<VecGenericData<N,3>,0,1,2>         { };
template <typename N> struct TVecN<N,4> : public VecGeneric<VecGenericData<N,4>,0,1,2,3>       { };
template <typename N> struct TVecN<N,5> : public VecGeneric<VecGenericData<N,5>,0,1,2,3,4>     { };
template <typename N> struct TVecN<N,6> : public VecGeneric<VecGenericData<N,6>,0,1,2,3,4,5>   { };
template <typename N> struct TVecN<N,7> : public VecGeneric<VecGenericData<N,7>,0,1,2,3,4,5,6> { };
// ...

如下所示：

template <typename D, size_t... Offsets> struct VecGeneric;
template <typename N, size_t C> struct VecGenericData;

template <typename N, size_t D> struct TVecN : public VecGeneric<VecGenericData<N,D>,IntPack<D>...> { };

推荐答案

构建整数序列 0 ，1,2，...，N-1 给定 N 通常递归地完成;例如：

Constructing the integer sequence 0,1,2,...,N-1 given N is typically done recursively; for example:

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

namespace detail
{
    template<size_t N, size_t... Is>
    struct make_index_sequence_h
        : make_index_sequence_h<N-1, N-1, Is...>
    {};

    template<size_t... Is>
    struct make_index_sequence_h<0, Is...>
    {
        using type = index_sequence<Is...>;
    };
}

template<size_t N>
using make_integer_sequence = typename detail::make_integer_sequence_h<N>::type;

（Àla C ++ 1y StdLib）

(À la C++1y StdLib)

要使用这些整数，您可以从 index_sequence 类型中推导出这些整数：

To use these integers, you deduce them from the index_sequence type:

namespace detail
{
    template<typename N, class IndexSequence>
    struct helper;

    template<typename N, size_t... Is>
    struct helper<N, index_sequence<Is...>> // deduce the integers
    {
        using type = VecGeneric<VecGenericData<N, sizeof...(Is)>, Is...>;
    };
}

上面是一个元函数，它将计算从。
使用别名模板简化用法：

The above is a metafunction that will "compute" the type you want to derive from. Simplify the usage using an alias template:

namespace detail
{
    template<typename N, size_t D>
    using helper_t = typename helper<N, make_index_sequence<D>>::type;
}

结果：

template <typename D, size_t... Offsets> struct VecGeneric
{
    // just a quick test:
    void print()
    {
        std::cout << __PRETTY_FUNCTION__ << "\n";
    }
};

template <typename N, size_t C> struct VecGenericData {};

template <typename N, size_t D> struct TVecN : public detail::helper_t<N, D> {};

int main()
{
    TVecN<int, 5>().print();
}

这篇关于如何生成可变参数包？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！