C++ 有没有一种方法可以将std:：variant与任意多个定义的类型一起使用？

我正在学习使用

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....
};

模板
结构MyType{
tx；
};
模板
我的班级{
公众：
myy型；
int z=N；
双w；
MyClass（双b）{
w=b；
}
};
模板
使用my_type_list=std:：variant<
MyClass，MyClass，MyClass，…，MyClass
>;
模板
std:：vector my_big_list={
MyClass{2.0}，
MyClass{3.0}，
MyClass{9.4}，
MyClass{1.3}，
MyClass{2.5}，
MyClass{3.2}，
等
};

但是整数

N

原则上可以是任何东西

---

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

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

#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>>);

#包括
#包括
#包括
模板
结构MyType{
tx；
};
模板
类MyClass{
myy型；
int z=N；
};
模板结构my_type_helper；
模板
结构我的\u类型\u助手{
typedef std:：variant_t；
};
模板
使用我的类型=
typename my\u type\u helper:：variant\u；
静态断言（std:：is_same_v）；

static\u断言

证明了

myu类型

等同于

std:：variant

---

p.S.

intz=N应该是
constexpr int z=N
您可以使用
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>{}));

模板
自动我的类型列表（标准：：索引序列）
->std:：variant；//不需要定义，我们只需要返回类型
模板
使用我的类型列表
=decltype（my_type_list_impl（std:：make_index_sequence{}））；

这里有一个
也许你在找
std:：any
？它可以是任何类型，也可以列出每种类型。你不能两全其美。我不知道，我不知道任意的许多类型应该来自哪里。实际上是一个范围[1，N]，就像你在这里看到的那样？把
N
作为
my_type_list
模板的第二个模板参数，然后写下所有的巫毒使其工作，就像上面说的那样？如果你不知道你在编译时想要的所有类型，那么你可以使用
std:：any
。如果你想让它们出现在一个变量中，那么这个变量需要在编译时知道它可能包含的所有类型，但显然你必须在某个地方编辑N的值，不是吗？我认为这个问题需要一个更准确地描述你试图做什么的例子，因为顺序N的例子似乎不相关。