将枚举映射到模板类型

Question

I have a type ValueWrapper , which can store one of several value types, identified by an enum:

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

Now I want to define a bunch of functions that take a ValueWrapper as argument and redirect the actual value to another function, eg:

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

Problem is, I have quite a lot of types and functions, and I'd rather not have to do an overly long switch-case for every single one.

Is there some way I could do something like this instead (pseudo-code) with modern C++, so I only have to do the switch-case once to determine the actual type?:

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

Use a using ValueWrapper=std::variant<double,std::string,...> instead.

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

if you want shared ownership logic, make it either a variant of shared ptr, or a shared ptr to a variant.

I mean, you can reinvent the wheel, but why?

If you are completely opposed to changing layout, the next thing I'd do is make a variant of

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

tag_t<double> etc, map the enum manually to the variant, and then use visit to get the 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>;
  }
}

etc

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

this technique is 100s of times easier than doing it manually; I have done both.