Question

我有一个类型 ValueWrapper，它可以存储多种值类型之一，由枚举标识：

enum class Type : uint32_t
{
    Float = 0,
    String,
    // etc
};

struct ValueWrapper
{
    ValueWrapper(float f)
        : type{Type::Float},data{std::make_shared<float>(f)}
    {}
    ValueWrapper(std::string str)
        : type{Type::String},data{std::make_shared<std::string>(str)}
    {}
    Type type;
    std::shared_ptr<void> data;
};

现在我想定义一堆以 ValueWrapper 作为参数并将实际值重定向到另一个函数的函数，例如：

void print(const ValueWrapper &v)
{
    switch(v.type)
    {
    case Type::Float:
        std::cout<<*static_cast<float*>(v.data.get());
        break;
    case Type::String:
        std::cout<<*static_cast<std::string*>(v.data.get());
        break;
    }
}

size_t size_of(const ValueWrapper &v)
{
    switch(v.type)
    {
    case Type::Float:
        return sizeof(float);
    case Type::String:
        return sizeof(std::string);
    }
}

template<typename TFrom>
    bool is_convertible(Type tTo)
{
    switch(tTo)
    {
    case Type::Float:
        return std::is_convertible_v<TFrom,float>;
    case Type::String:
        return std::is_convertible_v<TFrom,std::string>;
    }
}

问题是，我有很多类型和函数，我宁愿不必为每一个都做一个过长的 switch-case。

有什么办法可以用现代 C++ 来做这样的事情（伪代码），所以我只需要做一次 switch-case 来确定实际类型？：

type TO_TEMPLATE_TYPE(Type t)
{
    switch(t)
    {
    case Type::Float:
        return float;
    case Type::String:
        return std::string;
    }
}

template<typename TFrom>
    bool is_convertible(Type tTo)
{
    return std::is_convertible_v<TFrom,TO_TEMPLATE_TYPE(tTo)>;
}

Answer 1

改用 using ValueWrapper=std::variant<double,std::string,...>。

void print(const ValueWrapper &v)
{
  std::visit([](auto const& val){ std::cout<<val; }, v );
}

如果您想要共享所有权逻辑，请将其设为共享 ptr 的变体，或将其设为变体的共享 ptr。

我的意思是，你可以重新发明轮子，但为什么呢？

如果你完全反对改变布局，我接下来要做的就是制作一个

的变体

template<class T>struct tag_t{using type=T;};
template<class T>constexpr tag_t<T> tag={};

tag_t<double> 等，手动将枚举映射到变体，然后使用访问获取 tag_t<T>

std::variant<tag_t<double>,tag_t<std::string>> get_tag(Type e){
  switch (e){
    case Type::Float: return tag<double>;
    case Type::String: return tag<std::string>;
  }
}

等

void print(ValueWrapper const& v){
  auto tag=get_tag(v.type);
  std::visit([&](auto tag){
    using T=decltype(tag)::type;
    T* p=static_cast<T*>(v.data.get());
    std::cout<<*p;
  }, tag);
}

这种技术比手动操作要容易 100 倍；我两个都做过。

将枚举映射到模板类型

1 个答案: