How to convert in compile time a `std::make_index_sequence<N>` to `parametrized_type<0,1,2,3,...,N-1>` [关闭]

Question

我用整数参数化了一个模板类

template<unsigned int I> class TemplClass{};

然后我为

template alias

定义一个

std::variant

：

template<template<unsigned int I> class TC, unsigned int ... Is>
using TC_variant = typename std::variant<TC<Is>...>;

我编写了丑陋的代码（并且不容易扩展）：

using my_variant = TC_variant<TemplClass,
     0,  1,  2,  3,  4,  5,  6,  7,  8,  9
>; 

现在我想用

std::make_index_sequence<N>

来定义相同的混凝土

my_variant

：

// BAD : IT NOT COMPILES
using my_variant = TC_variant<TemplClass,std::make_index_sequence<64>>; 

此代码无法编译，因为

std::integer_sequence<std::size_t, 0, 1, ... ,N-1>

不是

0 , 1 , ... , N-1

（伪代码，不是 C++）。 ¿如何“conversion”？

编译的代码是：

    #include <variant>
    
    // Template class parametrized with an integer value
    template <unsigned int I> class TemplClass{};
    
    // Template alias for a definition of the 
    // variant template type needed
    template<template<unsigned int I> class TC, unsigned int ...Is>
    using TC_variant = typename std::variant<TC<Is>... >;
    
    // Type that I want to instantiate
    using my_variant = TC_variant<TemplClass,
         0,  1,  2,  3,  4,  5,  6,  7,  8,  9
    >;
    int main() {
        my_variant var = TemplClass<3>{};
        return 0;
    } 

    

Answer 1

假设第一个别名应该是

template<template<unsigned int I> class TC, unsigned int ... Is>
using TC_variant = typename std::variant<TC<Is>...>;
//                                       ^^^  ^

您可以使用类型特征来提供必要的间接并从索引序列中推导出包：

template <template <std::size_t I> class TC, class>
struct TC_variant;

template <template <std::size_t I> class TC, std::size_t... Is>
struct TC_variant<TC, std::index_sequence<Is...>> {
  using type = std::variant<TC<Is>...>;
};

template <template <std::size_t I> class TC, class TSeq>
using TC_variant_t = typename TC_variant<TC, TSeq>::type;

using my_variant = TC_variant_t<TemplClass, std::make_index_sequence<64>>;