如何支持 Variant 类型的隐式转换，例如从 int 到 unsigned long？

Question

我正在尝试使用我的 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

Answer 1

大致如下：

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>, 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

Answer 2

对于基于 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
 }

如何支持 Variant 类型的隐式转换，例如从 int 到 unsigned long？

How to support implicit conversion from a Variant type, e.g. from int to unsigned long?

c++

type-conversion

variant

c++17

编辑