如何支持從 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));
}

演示

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
 }