如何支持 Variant 类型的隐式转换，例如从整数到无符号长？

如何解决如何支持 Variant 类型的隐式转换，例如从整数到无符号长？

我正在尝试让我的 Variant 类型（c++17 的 std::variant 的包装器）在适当的情况下在类型之间进行隐式转换。例如，char 到 std::string，或 int 到 unsigned long。这是我的代码：

#include <variant>

using variant_t = std::variant<
        std::monostate,std::string,bool,std::int32_t,std::uint32_t,std::int64_t,std::uint64_t,float,double,char,unsigned char,std::vector<double>>;

class Variant : public variant_t {
public:

    using variant::variant;

    enum TypeId {
        EMPTY = 0,// std::monostate. Empty is default when variant instantiated with nothing
        STRING = 1,BOOL = 2,INT32 = 3,UINT32 = 4,INT64 = 5,UINT64 = 6,FLOAT = 7,DOUBLE = 8,CHAR = 9,UCHAR = 10,DOUBLEVECTOR = 11
    };

    TypeId type() const {
        return (Variant::TypeId) index();
    }

    template<class VariantType>
    VariantType get() const {
        return std::get<VariantType>(*this);
    }
};

我想要做的是：

TEST(VariantTests,HowToConvertIntToULongWithoutManualCast) {
    Variant v(11);
    ASSERT_EQ(v.type(),Variant::TypeId::INT32); // (pass,v is an int)
    unsigned long toUnsignedLong = v; // error
    long toLong = v; // error
    // and any other conversions from int that make sense
}

如何修改我的 Variant 以支持隐式类型转换？

编辑

根据评论，我还需要考虑不兼容的对以及兼容的对，例如以下将失败。

Variant v(12); // variant containing an int
std::string x = v; // should error,int to string incompatible

解决方法

大致如下：

template <typename T>
struct Visitor {
  template <typename U>
  std::enable_if_t<std::is_convertible_v<U,T>,T> operator() (U&& val) {
      return val;
  }

  template <typename U>
  std::enable_if_t<!std::is_convertible_v<U,T> operator() (U&& val) {
      throw std::bad_variant_access{};
  }
};

template<class VariantType>
VariantType get() const {
    return std::visit(Visitor<VariantType>{},static_cast<const variant_t&>(*this));
}

Demo

,

对于基于 operator T () 的解决方案（但将 std::variant 作为成员，而不是继承）

  template <typename T>
  operator T () const 
   {
     return std::visit(
        [](auto const & val)
        { if constexpr ( std::is_convertible_v<decltype(val),T> )
             return T(val);
           else
            { throw std::bad_variant_access{}; return T{}; } },var); 
   }

下面是一个完整的编译示例

#include <vector>
#include <string>
#include <variant>
#include <cstdint>
#include <type_traits>

using variant_t = std::variant<
        std::monostate,std::string,bool,std::int32_t,std::uint32_t,std::int64_t,std::uint64_t,float,double,char,unsigned char,std::vector<double>>;

class Variant
 {

   public:
      variant_t  var_;

    explicit Variant (variant_t var)
    : var_(std::move(var)){}

      enum TypeId
       {
         EMPTY = 0,STRING = 1,BOOL = 2,INT32 = 3,UINT32 = 4,INT64 = 5,UINT64 = 6,FLOAT = 7,DOUBLE = 8,CHAR = 9,UCHAR = 10,DOUBLEVECTOR = 11
       };

      TypeId type () const
       { return (Variant::TypeId) var_.index(); }

      template <typename VariantType>
      VariantType get () const
       { return std::get<VariantType>(var_); }

      template <typename T>
      operator T () const 
       {
         return std::visit(
            [](auto const & val)
            { if constexpr ( std::is_convertible_v<decltype(val),T> )
                 return T(val);
               else
                { throw std::bad_variant_access{}; return T{}; } },var_); 
       }
 };

int main()
 {
   Variant  v{12};

   long l = v;  // compile and works run-time

   std::string s = v; // compile and throw run-time
 }