主页 / coding / 问题 / 79493652
Accepted
DBS4261
Asked: 2025-03-08 07:59:28 +0800 CST

从数组中创建一个变体，其元素被转换成类型

  • 772

在编写一些库绑定代码时，我尝试定义基于数组的类型，遇到了一个奇怪的挑战。

考虑如下的枚举：

enum class MyTypes
{
    UInt,
    Int,
    Float
}

利用某些类型特征，我可以将枚举值转换为类型：

template <MyTypes Ty> struct typeify;
template <> struct typeify<MyTypes::UInt> { using type = unsigned int; };
template <> struct typeify<MyTypes::Int> { using type = int; };
template <> struct typeify<MyTypes::Float> { using type = float; };
template <MyTypes Ty> using typeify_t = typename typeify<Ty>::type;

为了帮助绑定，我还有这个（因为 C++ 没有反射）：

inline static constexpr std::array KnownTypes 
{ 
    std::pair{"UInt", MyTypes::UInt},
    std::pair{"Int", MyTypes::Int},
    std::pair{"Float", MyTypes::Float}
};

从这里，我想std::variant根据已知的类型定义一个。

有了 3 个值，显然只需像这样写出变量：

std::variant<unsigned int, int, float>

std::variant但在我的情况中，我有 50 多种类型。因此，我希望有一种方法可以从数组KnownTypes和类型特征中自动生成类型定义typeify_t。

我认为我已经接近以下内容，但由于无法为可变模板参数提供默认值，我受到了困扰：

template <template <typename T, T ... Idx> class temp = std::make_index_sequence<KnownTypes.size()>>
using AnyKnownType = std::variant<typeify_t<KnownTypes[Idx].second>, ...>;
c++

3 个回答

  1. Best Answer

    编程中的任何问题都可以通过另一个间接级别来解决（间接级别过多除外）。

    不要直接创建using表达式模板，而是创建函数模板声明并在using表达式中使用其返回类型：

    template <std::size_t... Is>
std::variant<typeify_t<KnownTypes[Is].second>...>
make_variant_type(std::index_sequence<Is...>);

using AnyKnownType = decltype(make_variant_type(std::make_index_sequence<KnownTypes.size()>()));

    演示

    • 3

  2. 使用部分专门化我建议：

    #include <variant>
#include <cstddef>

// Helper template to generate a variant type from KnownTypes.
template <typename IndexSeq> struct variant_maker_impl;

template <std::size_t... Is> struct variant_maker_impl<std::index_sequence<Is...>>
{
    using type = std::variant< typeify_t<KnownTypes[Is].second>... >;
};

// Alias for the generated variant type.
using AnyKnownType = typename variant_maker_impl<std::make_index_sequence<KnownTypes.size()>>::type;

    据我所知，这是您可以轻松想到的选项。由于 C++ 关于别名模板的规则，您无法直接部分特化别名模板。别名模板不允许部分特化，这意味着您无法编写不使用辅助结构即可“解开”索引序列的别名。因此，无法从上述方法转换为您的方法。

    ((查看现场演示))

    • 3

  3. 实际上，您为框架定义了 3 个不同的序列：

    • 枚举

    • 模板特化列表

    • 将枚举值链接到字符串的数组

    您至少可以减少到 2 个序列，如下所示：

    1. 保存枚举值的数组

    2. 模板特化列表。由于它们是相关的，因此最好将类型和相关字符串都放在此处

    然后，您可以按照将 constexpr 数组的内容转换为参数包的可能性来构建变体（请参阅此处的通用方法），这导致：

    #include <array>
#include <variant>

#define VALUES UInt, Int, Float
enum  MyTypes {VALUES};
constexpr std::array MyTypesArray = {VALUES};

template <MyTypes Ty> struct typeify;
template <> struct typeify<MyTypes::UInt>  { constexpr static const char* name="UInt";  using type = unsigned int; };
template <> struct typeify<MyTypes::Int>   { constexpr static const char* name="Int";   using type = int;          };
template <> struct typeify<MyTypes::Float> { constexpr static const char* name="Float"; using type = float;        };

////////////////////////////////////////////////////////////////////////////////
// see https://stackoverflow.com/questions/60434033/how-do-i-expand-a-compile-time-stdarray-into-a-parameter-pack
template <auto arr, template <auto...> typename Consumer, typename IS = decltype(std::make_index_sequence<arr.size()>())>
struct Generator;

template <auto arr, template <auto...> typename Consumer, std::size_t... I>
struct Generator<arr, Consumer, std::index_sequence<I...>> 
{
    using type = Consumer<arr[I]...>;
};

////////////////////////////////////////////////////////////////////////////////
template <auto...s> 
struct ToVariantConsumer  { using type = std::variant <typename typeify<s>::type...>;  };

using AnyKnownType = typename Generator<MyTypesArray, ToVariantConsumer>::type::type;

static_assert (std::is_same_v<AnyKnownType, std::variant<unsigned int, int, float> >);

////////////////////////////////////////////////////////////////////////////////
int main() {}

    #define请注意，为了避免定义枚举和定义保存所有枚举值的数组的冗余，使用的方法并不那么漂亮（这是另一个故事，解决方案似乎存在）。

    c++20还要注意，它将从（即在定义中使用类类型的非类型模板参数）开始运行Generator。

    • 1

相关问题