5

我只是在学习使用std::variant，我想声明一个类型列表，其中包含（原则上）任意许多我的用户定义类型。即，类似

template<typename T>
struct MyType{
    T x;
};

template<typename T, int N>
MyClass{
public:
    MyType<T> y;
    int z = N;
    double w;
    MyClass(double b){
        w = b;
    }
};

template<typename T>
using my_type_list = std::variant<
    MyClass<T,1>, MyClass<T,289>, MyClass<T,13>, ...., MyClass<T,5001>
>;

template<typename T>
std::vector<my_type_list> my_big_list = {
    MyClass<T,1> { 2.0 },
    MyClass<T,1> { 3.0 },
    MyClass<T,289> { 9.4 },
    MyClass<T, 13> { 1.3 },
    MyClass<T, 5001> {2.5},
    MyClass<T, 5001> {3.2},
    ..... etc....
};

但是整数N原则上可以是任何东西。

有什么办法可以做到这一点？

4

2 回答 2

1

您可以使用std::index_sequence创建一系列编译时索引，然后使用它来创建std::variant带有这些索引的非类型模板参数的可变参数包。

template<typename T, std::size_t ...Is>
auto my_type_list_impl(std::index_sequence<Is...>) 
  -> std::variant<MyClass<T, Is + 1>...>;  // no definition needed, we just need the return type

template<typename T, int N>
using my_type_list 
  = decltype(my_type_list_impl<T>(std::make_index_sequence<N>{}));

这是一个演示

于 2021-03-14T17:19:48.207 回答
1

您表示您正在寻找使用另一个模板参数来指定变体中的值的数量。在这种情况下，使用它来构造一个std::integer_sequence是一件简单的事情，然后用它来创建你的变体类型列表。

#include <variant>
#include <type_traits>
#include <utility>

template<typename T>
struct MyType{
    T x;
};

template<typename T, int N>
class MyClass{
    MyType<T> y;
    int z = N;
};

template<typename T, typename sequence> struct my_type_helper;

template<typename T, int ...N>
struct my_type_helper<T, std::integer_sequence<int, N...>> {

    typedef std::variant<MyClass<T, N>...> variant_t;
};

template<typename T, int N>
using my_type=
    typename my_type_helper<T, std::make_integer_sequence<int, N>>::variant_t;

static_assert(std::is_same_v<std::variant<MyClass<int, 0>,
          MyClass<int, 1>,
          MyClass<int, 2>>,

          my_type<int, 3>>);

static_assert证明my_type<int, 3>等价std::variant<MyClass<int, 0>, MyClass<int, 1>, MyClass<int, 2>>于。

PSint z = N;应该可能是constexpr int z=N;。

于 2021-03-14T17:17:17.987 回答