将指针作为正确类型放入模板中的 std::variant答案

【问题标题】：emplace pointer as proper type into std::variant in template将指针作为正确类型放入模板中的 std::variant
【发布时间】：2022-11-17 14:06:58
【问题描述】：

是否可以将一些 void* 指针放入具有运行时生成的索引的变体中。

这个不错的解决方案（来自link）是否可以更新以获取指向 emplace 的索引和指针？

#include <variant>

template <typename... Ts, std::size_t... Is>
void next(std::variant<Ts...>& v, std::index_sequence<Is...>)
{
    using Func = void (*)(std::variant<Ts...>&);
    Func funcs[] = {
        +[](std::variant<Ts...>& v){ v.template emplace<(Is + 1) % sizeof...(Is)>(); }...
    };
    funcs[v.index()](v);
}

template <typename... Ts>
void next(std::variant<Ts...>& v)
{
    next(v, std::make_index_sequence<sizeof...(Ts)>());
}

可以获得所需的数据类型是可能的，但无论如何不要认为它有帮助

           Func funcs[] = {
                [](MessageTypesVariant& v) {
                    auto y = std::get<(Is)>(v);
                    auto z = std::forward<decltype(y)>(y);
                    v.template emplace<(Is)>(); }...
            };

【问题讨论】：

您是否正在寻找类似这样的签名：template <typename... Ts> void next(std::variant<Ts...>& v, const std::tuple<Ts>& value_to_emplace)？
最后，我需要这样的东西（虽然不知道是否可能）：template <typename... Ts> void next(std::variant<Ts*...>& v, int typeIndex, void* ptrToData)

标签： c++ templates std-variant

【解决方案1】：

你可以这样做，解压 Ts... 并检查类型是否匹配。

template <typename T, typename... Ts>
bool set(std::variant<Ts*...>& v, int typeIndex, void* ptrToData) {
    constexpr static auto idx = index_v<T, Ts...>;
    if (idx == typeIndex) {
        v.template emplace<idx>(static_cast<T*>(ptrToData));
        return true;
    }
    return false;
}

template <typename... Ts>
void set(std::variant<Ts*...>& v, int typeIndex, void* ptrToData) {
    (set<Ts, Ts...>(v, typeIndex, ptrToData) || ...);
}

在这里，您需要一种从类型列表中索引类型的方法，index_v，这是类型列表中使用的一种常用技术。

// index
inline constexpr std::size_t npos = -1;

template <typename T, typename... Ts>
struct index : std::integral_constant<std::size_t, npos> {};

template <typename T, typename... Ts>
inline constexpr std::size_t index_v = index<T, Ts...>::value;

template <typename T, typename... Ts>
struct index<T, T, Ts...> : std::integral_constant<std::size_t, 0> {};

template <typename T, typename Head, typename... Tail>
class index<T, Head, Tail...> {
    static constexpr std::size_t tmp = index_v<T, Tail...>;

public:
    static constexpr std::size_t value = tmp == npos ? tmp : tmp + 1;
};

Demo

【讨论】：